robust-first（robust first 搜索）

Robust-First

*"Survive first. Be correct later."*

What Is It?

Robust-First is Dave Ackley's principle: systems should prioritize survivability over correctness.

A system that crashes when confused is useless. A system that limps along incorrectly but keeps running can be repaired.

The Philosophy

Traditional computing:

IF error THEN crash
"Fail fast and loud"

Robust-first computing:

IF error THEN repair_locally AND continue
"Stay alive and heal"

Core Principles

1. Never Crash

# WRONG
if missing_field:
    raise Error("Field required!")

# RIGHT
if missing_field:
    log_warning("Field missing, using default")
    field = reasonable_default

2. Local Repair

Don't wait for global consistency. Fix what you can, where you are:

# Found inconsistency
character.location: room-A
room-A.occupants: [not including character]

# Local repair
room-A.occupants.append(character)
log: "Repaired: added character to room-A occupants"

3. Degrade Gracefully

When resources are limited, do less but keep working:

# Full capability
- semantic search
- syntax highlighting
- auto-complete
- error detection

# Degraded (low memory)
- basic search only
- plain text
- manual completion
- errors on save only

4. Redundancy

Important state exists in multiple places:

# Character location recorded in:
- character.yml → location field
- room/ROOM.yml → occupants list
- session-log.md → movement events

# If one is corrupted, recover from others

The Movable Feast Machine

Dave Ackley's Movable Feast Machine (MFM):

• Computation spread across unreliable substrate
• No global clock, no central control
• Elements repair themselves and neighbors
• Errors are normal, not exceptional

MOOLLM inherits this:

• Files can be corrupted — repair from redundancy
• Schemas can drift — reconcile gracefully
• Context can overflow — summarize and continue
• Tools can fail — retry or work around

Anti-Fragility

Beyond robust — anti-fragile:

When something goes wrong, capture the lesson:

# Error occurred
repair_log:
  - issue: "Character teleported without movement event"
    repair: "Added movement event retroactively"
    lesson: "Always log movements before updating location"

# Next time: system knows to check this

MOOLLM Application

Self-Repair Demon

A background process that:

1. Scans for inconsistencies
2. Attempts local repairs
3. Logs what it fixed
4. Escalates what it couldn't

See: self-repair/

POSTEL for Errors

When encountering malformed input:

1. Try to parse anyway
2. Infer missing parts
3. Flag assumptions
4. Continue working

See: postel/

Never Delete

Instead of deleting, archive:

• Corrupted files → .archive/corrupted/
• Old versions → .archive/versions/
• Failed attempts → .archive/failed/

Recovery is always possible.

Example: Corrupted Room

# room/ROOM.yml has parse error

Traditional response:
  "Error: Invalid YAML at line 42"
  [System halts]

Robust-first response:
  "Warning: ROOM.yml has syntax error"
  "Attempting recovery..."
  "- Loaded last known good state from git"
  "- Merged recent changes from session-log.md"
  "- Flagged line 42 for manual review"
  [System continues with recovered state]

Dovetails With

Sister Skills

• self-repair/ — Checklist-based healing
• postel/ — Charitable interpretation

Kernel

• kernel/self-healing-protocol.md — Full specification

Protocol Symbols

ROBUST-FIRST   — Survive over correct
NEVER-CRASH    — Always keep running
REPAIR-DEMON   — Background fixer
BEST-EFFORT    — Do what you can
NEVER-DELETE   — Archive, don't destroy

See: PROTOCOLS.yml