empathic-templates

Smart templates that understand semantic intent, not just string substitution

Repositório: SimHacker/moollm
Última atividade na origem: 24 de março de 2026 às 12:04
Idioma detectado do SKILL.md: inglês
Estrelas: 49
Forks: 6

Opções de instalação

Por padrão, está selecionado o prompt que primeiro revisa a origem. Você pode mudar para um comando direto ou baixar uma cópia local.

Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.

Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.

npx skills add https://github.com/SimHacker/moollm --skill empathic-templates

O comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.

Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.

Revise os arquivos de origem

Leia o SKILL.md e os arquivos complementares exibidos pelo SkillsMP antes de decidir se vai instalar.

Explorador de arquivos

5 arquivos

SKILL.md

Instruções da origem · Visualização somente leitura

Voltar à pesquisa Voltar à instalação

protocol

Protocol names ARE K-lines.

2026-08-06

mind-mirror

Personality modeling system based on Timothy Leary's 1985 software + The Sims traits

2026-08-06

soul-city

Liminal place prototype — rooms, shops, tools, objects; souls walk here

2026-08-02

Ver todas deste repositório

Hello {{name}}!

Your order {{order_id}} has shipped.
Items: {{items}}
Total: ${{total}}

# The template understands context
greeting: "{{appropriate_greeting}}"
order_summary: "{{summarize_order_naturally}}"
items: "{{list_items_with_quantities}}"
total: "{{format_currency(total)}}"

template: |
  # {{character_name}}
  
  {{describe_appearance}}
  
  ## Personality
  {{personality_as_prose}}
  
  ## Catchphrase
  > "{{generate_catchphrase}}"

context:
  character_type: "grumpy wizard"
  setting: "medieval fantasy"
  tone: "humorous"
  age: "ancient"

# Grumbald the Insufferable

A stooped figure wrapped in robes that were probably purple
once, before centuries of potion stains and cat hair took
their toll. His beard reaches his knees and contains at
least three quills, a small bird's nest, and what might be
a sandwich from the Third Age.

## Personality

Grumbald has perfected the art of making everyone feel
slightly stupid. He answers questions with questions,
sighs dramatically at simple requests, and has been
known to turn people into newts for using incorrect
grammar. Deep down, he cares — but he'd rather be
turned into a newt himself than admit it.

## Catchphrase

> "I've forgotten more magic than you'll ever know.
> Literally. Where did I put my staff?"

{{variable}}           # Simple substitution (still works)
{{expression}}         # Empathic expression (interpreted)
{{#if condition}}      # Conditional (condition is interpreted)
{{#each items}}        # Iteration (smart about structure)
{{> partial}}          # Include another template

{{describe_X}}         # Generate description based on context
{{summarize_Y}}        # Create summary of data
{{generate_Z}}         # Create new content fitting context
{{appropriate_W}}      # Choose fitting value from possibilities
{{format_V}}           # Intelligent formatting

{{#if character.is_hungry}}
  {{describe_hunger_behavior}}
{{/if}}

{{#if player.reputation > 50}}
  # The guard recognizes you
  {{guard_friendly_greeting}}
{{else}}
  # The guard is suspicious
  {{guard_suspicious_challenge}}
{{/if}}

# CHARACTER.yml.tmpl
id: {{generate_unique_id}}
name: "{{character_name}}"
species: "{{species}}"
description: |
  {{describe_appearance_based_on_species_and_personality}}

personality:
  {{infer_sims_traits_from_description}}

catchphrase: "{{generate_fitting_catchphrase}}"

backstory: |
  {{generate_backstory_consistent_with_setting}}

# ROOM.yml.tmpl
room:
  name: "{{room_name}}"
  type: {{room_type}}
  
  description: |
    {{describe_room_atmospherically}}
    
    {{describe_notable_features}}
    
    {{hint_at_secrets_if_any}}

  exits:
    {{generate_exits_based_on_maze_topology}}
    
  objects:
    {{place_appropriate_objects}}

# SESSION.md.tmpl
## Session {{session_number}} — {{session_date}}

### Summary
{{summarize_session_events}}

### Key Moments
{{list_memorable_moments}}

### State Changes
{{document_world_changes}}

### Next Steps
{{suggest_continuation_hooks}}

{{user.name}}                    # Simple lookup
{{user.status | capitalize}}     # With filter
{{player.has_item('key')}}       # Method call

{{#if character.mood == 'happy'}}  # Exact match
{{#if character.is_friendly}}       # Boolean inference
{{#if gold > 100}}                  # Numeric comparison
{{#if player.can_afford(item)}}     # Method evaluation

{{#each inventory.items}}
  - {{this.name}}: {{this.description}}
{{/each}}

# Generate SQL for the report
query: |
  {{empathic_sql: "get all users who ordered in the last month"}}

# Generate the email
email: |
  Dear {{user.name}},
  
  {{summarize_monthly_orders_naturally}}
  
  Total spent: {{format_currency(monthly_total)}}

# CHARACTER.yml.tmpl — Character sheet template
# 
# Required context:
#   - character_name: string
#   - species: string  
#   - setting: string (e.g., "medieval fantasy")
#
# Optional context:
#   - personality_hints: list of traits
#   - backstory_seeds: key events to include
#   - tone: "serious" | "humorous" | "dark" (default: "neutral")

id: {{generate_unique_id}}
name: "{{character_name}}"
# ... rest of template

# TEMPLATE: This section describes the character's appearance
# INSTRUCTION: Use vivid sensory details
# NOTE: Keep under 100 words
# TODO: Add more variety to hair colors
description: |
  {{describe_appearance}}

# This character was created using the incarnation protocol.
# See skills/incarnation/SKILL.md for details.
description: |
  {{describe_appearance}}

# Sims traits determine interaction success rates
sims_traits:
  {{generate_traits}}

Indicator	Type	Action
`# TEMPLATE:`, `# INSTRUCTION:`, `# NOTE:`	Meta	Strip
`# TODO:`, `# FIXME:` in template context	Meta	Strip
`# This explains...`, `# See also...`	Concrete	Preserve
Comments inside `{{...}}` blocks	Meta	Strip
Comments explaining generated values	Concrete	Preserve
ALL CAPS directive style	Meta	Strip
Lowercase explanatory style	Concrete	Preserve

# TEMPLATE: Character soul file
# INSTRUCTION: Generate YAML Jazz style comments

# This character was incarnated via the full autonomy protocol.
id: {{generate_id}}
name: "{{character_name}}"

# INSTRUCTION: Describe based on species and personality
description: |
  {{describe_appearance}}

# Personality traits affect all interactions
# Higher values = stronger tendency
sims_traits:
  nice: {{nice_value}}  # 0-10, affects social success
  # INSTRUCTION: Infer from description
  playful: {{infer_playful}}

# This character was incarnated via the full autonomy protocol.
id: palm-001
name: "Palm"

description: |
  A small capuchin monkey with knowing eyes and surprisingly
  dexterous fingers. Palm moves with the confidence of someone
  who has already seen how this story ends.

# Personality traits affect all interactions
# Higher values = stronger tendency
sims_traits:
  nice: 7  # 0-10, affects social success
  playful: 9

prototype: skills/character/CHARACTER.yml.tmpl
  ↓ instantiate with context
instance: examples/adventure-4/characters/animals/monkey-palm/CHARACTER.yml

# BUFF.yml.tmpl
buff:
  id: {{buff_id}}
  name: "{{buff_name}}"
  type: {{buff_type}}
  
  description: |
    {{describe_buff_effect_flavorfully}}
  
  mechanics:
    duration: {{duration}}
    effect: "{{describe_mechanical_effect}}"
    
  trigger: "{{empathic_expression: trigger_condition}}"
  
  flavor_text: |
    {{generate_flavor_text_matching_setting}}

buff_name: "Sugar Rush"
buff_type: positive
trigger_condition: "eating candy or sweet treats"
setting: "whimsical candy land"

buff:
  id: sugar-rush
  name: "Sugar Rush"
  type: positive
  
  description: |
    Your eyes widen, your heart races, and suddenly
    EVERYTHING IS AMAZING. Colors are brighter, sounds
    are sweeter, and you're pretty sure you could
    outrun a unicorn.
  
  mechanics:
    duration: 10 minutes
    effect: "+20% speed, +10% charisma, -10% focus"
    
  trigger: "consuming_sweet_treat"
  
  flavor_text: |
    *The sugar hits your bloodstream like a 
    candy-coated lightning bolt. WHEEEEE!*

# ADVENTURE.yml.tmpl — Adventure State Schema
# 
# REQUIRED fields (must be provided):
#   - adventure.name: string
#   - player.character: path
#   - navigation.starting_room: path
#
# OPTIONAL fields (can be omitted, inherited, or use defaults):
#   - parameters.*: all have sensible defaults
#   - party.members: defaults to [player.character]
#   - evidence.*: starts empty
#
# COMPUTED fields (LLM generates):
#   - adventure.started: timestamp
#   - selection.targets: starts []

# Template has:
parameters:
  time:
    advancement: normal      # Default
  git:
    auto_commit: false       # Default
    auto_push: false         # Default
  debug:
    enabled: false           # Default
    # ...50 more lines of debug config...

# Smart instantiation DROPS the whole section:
# (No parameters block = use all defaults)

# Unless something differs:
parameters:
  debug:
    enabled: true            # Only what changed!

# REQUIRED: Must be provided during instantiation
adventure:
  name: "{{adventure_name}}"           # REQUIRED
  objective: "{{quest_objective}}"     # REQUIRED
  status: active                       # OPTIONAL: has default

# OPTIONAL: Can be omitted entirely
evidence:                              # OPTIONAL: section
  clues: []                            # OPTIONAL: default []
  items: []                            # OPTIONAL: default []

# COMPUTED: Generated by LLM or system
statistics:                            # COMPUTED: section
  rooms_explored: 0                    # COMPUTED: auto-increment
  turns_elapsed: 0                     # COMPUTED: auto-increment

# INHERITED: Comes from prototype
parameters:                            # INHERITED: from simulation skill
  # Only override what differs from skills/simulation/defaults.yml

Marker	Meaning	Instantiation Behavior
`# REQUIRED`	Must be filled	Error if missing
`# OPTIONAL`	Can be omitted	Drop if default or empty
`# OPTIONAL: default X`	Has default value	Drop if equals X
`# COMPUTED`	System generates	Never fill from context
`# INHERITED`	From prototype	Drop if unchanged
`# ABSTRACT`	Natural language OK	Keep as prose placeholder

# Template:
room:
  atmosphere: "{{atmosphere}}"         # ABSTRACT: describe the feeling

# Instantiation with abstract value (valid!):
room:
  atmosphere: |
    A sense of ancient mystery. Dust motes float in shafts of light 
    from high windows. Something important happened here, long ago.
    
# The LLM can work with this! It doesn't need structured data.

# skills/room/ROOM.yml.tmpl is the PROTOTYPE
# examples/adventure-4/maze/ROOM.yml is an INSTANCE

# The instance OMITS fields that match the prototype:
room:
  name: "Maze Entrance"     # DIFFERENT: specific name
  # purpose: omitted        # INHERITED: from prototype
  # working_set: omitted    # INHERITED: from prototype
  exits:
    north: corridor-1/      # DIFFERENT: specific exits
    east: dead-end/
  atmosphere: "Confusion and possibility"  # DIFFERENT: specific vibe

# adventure/schema.py — GENERATED FROM ADVENTURE.yml.tmpl

@dataclass
class Adventure:
    # REQUIRED fields (from template markers)
    name: str
    objective: str
    starting_room: str
    player_character: str
    
    # OPTIONAL fields (have defaults)
    status: str = "active"
    parameters: Optional[Parameters] = None  # Whole section optional
    
    # COMPUTED fields (not in __init__)
    started: str = field(init=False)
    turns_elapsed: int = field(init=False, default=0)
    
    # Unknown fields preserved for round-trip
    _extra: Dict[str, Any] = field(default_factory=dict)
    
    def __post_init__(self):
        self.started = datetime.now().isoformat()

// engine.js — GENERATED FROM templates

class Adventure {
  // REQUIRED
  name;        // string, must be set
  objective;   // string, must be set
  
  // OPTIONAL with defaults
  status = "active";
  parameters = null;  // null = use global defaults
  
  // COMPUTED (read-only, managed by engine)
  get started() { return this._started; }
  get turns_elapsed() { return this._turns; }
  
  constructor(data) {
    // Validate REQUIRED
    if (!data.name) throw new Error("Adventure requires name");
    if (!data.objective) throw new Error("Adventure requires objective");
    
    // Apply provided values
    Object.assign(this, data);
    
    // Preserve unknown fields
    this._extra = {};
    for (const [k, v] of Object.entries(data)) {
      if (!this.constructor.KNOWN_FIELDS.includes(k)) {
        this._extra[k] = v;
      }
    }
  }
}

# Template with expressions:
guard:
  allows_entry: "{{empathic_expression: player has the key OR player is known to guard}}"
  greeting: "{{generate: appropriate greeting based on player reputation}}"
  actions:
    - trigger: "{{when: player attempts to pass without permission}}"
      action: "{{do: block and challenge}}"
      score: "{{calculate: based on guard alertness and player stealth}}"

# Events for LLM compilation:
- event: COMPILE_EXPRESSION
  field: "guard.allows_entry"
  source: "player has the key OR player is known to guard"
  target_language: javascript
  expected_type: boolean
  output_field: "guard.allows_entry_js"  # Where to write the compiled expression
  # Naming convention: {field}_js for JavaScript, {field}_py for Python
  # The corresponding runtime classes know to eval these fields
  
- event: COMPILE_GENERATION
  field: "guard.greeting"
  instruction: "appropriate greeting based on player reputation"
  target_format: string
  context_needed: [player.reputation, guard.personality]
  
- event: COMPILE_SCORE
  field: "guard.actions[0].score"
  instruction: "based on guard alertness and player stealth"
  target_format: "number 0-100"
  inputs: [guard.alertness, player.stealth]

# After LLM compilation, the YAML now contains:
guard:
  allows_entry: "player has the key OR player is known to guard"
  allows_entry_js: |
    (ctx) => ctx.player.inventory.includes('key') || 
             ctx.guard.knownPlayers.includes(ctx.player.id)
  allows_entry_py: |
    lambda ctx: 'key' in ctx.player.inventory or 
                ctx.player.id in ctx.guard.known_players
                
  greeting: "appropriate greeting based on player reputation"
  greeting_js: |
    (ctx) => {
      if (ctx.player.reputation > 80) return "Welcome back, friend!";
      if (ctx.player.reputation > 50) return "You may pass.";
      return "Halt! State your business.";
    }

// engine.js runtime
class Guard {
  checkEntry(ctx) {
    if (this.allows_entry_js) {
      return eval(this.allows_entry_js)(ctx);  // Use compiled
    }
    return this.evaluateEmpathic(this.allows_entry, ctx);  // LLM fallback
  }
}

# schema.py runtime
class Guard:
    def check_entry(self, ctx):
        if self.allows_entry_py:
            return eval(self.allows_entry_py)(ctx)  # Use compiled
        return self.evaluate_empathic(self.allows_entry, ctx)  # LLM fallback

# Template-to-Code Pipeline
template_pipeline:
  - stage: "ADVENTURE.yml.tmpl"
    role: "Human-readable template/schema"
  - stage: "adventure.py lint"
    role: "Parse, validate, emit events"
    actions:
      - "Validate REQUIRED fields"
      - "Warn on missing OPTIONAL with no default"
      - "Emit COMPILE_EXPRESSION events"
      - "Emit COMPILE_GENERATION events"
      - "Emit COMPILE_SCORE events"
  - stage: "LLM receives events"
    role: "Compiles expressions"
  - stage: "adventure.py compile"
    role: "Generate output"
    outputs:
      - "adventure.json (minimal, machine-readable)"
      - "engine.js (with compiled expressions)"
      - "schema.py (Python classes for validation)"
      - "index.html (playable web app)"

# Linter checks:
validation:
  required_present:
    - adventure.name
    - adventure.objective
    - player.character
    - navigation.starting_room
    
  type_checks:
    - field: simulation.turn
      type: integer
      min: 0
      
    - field: parameters.difficulty
      type: enum
      values: [easy, normal, hard]
      
  expression_checks:
    - field: guard.allows_entry
      must_compile_to: boolean
      
  path_checks:
    - field: player.character
      must_exist: true
      must_be_type: directory

room:
  name: "{{name}}"                    # REQUIRED
  purpose: "{{purpose}}"              # OPTIONAL: default "general"
  created: "{{timestamp}}"            # COMPUTED
  
  context: []                         # OPTIONAL: default []
  cards_in_play: []                   # OPTIONAL: default []
  
  working_set:                        # INHERITED: from prototype
    - "ROOM.yml"
    - "README.md"
    - "state/*.yml"
    
  exits:                              # REQUIRED: at least one
    parent: "../"
    
  atmosphere: "{{atmosphere}}"        # ABSTRACT: natural language OK

# Only what's needed and different:
room:
  name: "Wizard's Study"
  exits:
    parent: "../"
    down: secret-lab/
  atmosphere: "Dusty tomes and arcane instruments"

description: "{{description}}"  # Just passes through
personality: "{{personality}}"  # No generation

description: |
  {{describe_character_based_on_traits_and_setting}}
  
personality:
  {{infer_traits_from_context}}

# Every room file repeats the same working_set:
working_set:
  - "ROOM.yml"
  - "README.md"
  - "state/*.yml"

# Omit working_set entirely — inherit from ROOM.yml.tmpl prototype
# Only include if this room has DIFFERENT requirements

EMPATHIC-TEMPLATES

name	empathic-templates
description	Smart templates that understand semantic intent, not just string substitution
license	MIT
tier	1
allowed-tools	["read_file","write_file"]
related	["moollm","empathic-expressions","postel","yaml-jazz","skill","incarnation","character","coherence-engine"]
tags	["moollm","generation","semantic","substitution","understanding"]

name	empathic-templates
description	Smart templates that understand semantic intent, not just string substitution
license	MIT
tier	1
allowed-tools	["read_file","write_file"]
related	["moollm","empathic-expressions","postel","yaml-jazz","skill","incarnation","character","coherence-engine"]
tags	["moollm","generation","semantic","substitution","understanding"]

Field	Output Field (JS)	Output Field (Py)
`allows_entry`	`allows_entry_js`	`allows_entry_py`
`score`	`score_js`	`score_py`
`guard.condition`	`guard.condition_js`	`guard.condition_py`

empathic-templates

Informações da origem

Opções de instalação

Revise os arquivos de origem

Mais deste repositório

Mais deste repositório

Empathic Templates

What Is It?

Empathic Templates

What Is It?

The Difference

Traditional Templates (Handlebars, Jinja, etc.)

Empathic Templates

How It Works

1. Parse Template

2. Understand Context

3. Semantic Generation

Template Syntax

Basic Slots

Empathic Slots (The Magic)

Expressions with Empathic Interpretation

Used For

Character Creation

Room Generation

Session Logs

The Empathic Expression Connection

Variables

Conditions

Iterations

Code-Switching IN Templates

Template Discovery Pattern

Comment Intelligence

Meta-Comments (Stripped)

Concrete Comments (Preserved)

How the LLM Knows

Example: Mixed Comments

The Principle

Relationship to Self-Style Inheritance

Examples

Instantiating a Buff

Templates as Schemas (CRITICAL!)

The Template-Schema Pattern

Smart Instantiation: The Drop Pattern

Schema Markers in Templates

Field Requirement Markers

Abstract Fields: Natural Language as Value

Prototype Inheritance

Code Generation from Templates

LLM Compilation Events

Output Field Naming Convention

The Full Template-to-Code Pipeline

Validation and Linting

Example: Smart Instantiation

Anti-Pattern: Dumb Templates

Anti-Pattern: Repeating Defaults

Dovetails With

Protocol Symbol