symbolica bestiary (agentica) — 프롬프트가 지식 경계를 긋는 멀티에이전트

This is a visual game designed for humans. You see it as a 64x64
coordinate grid of integers 0-15 ({COLOR_LEGEND}), due to the nature and limitations
of your interface. You use coordinates to identify positions and click, but game
mechanics and win conditions are about relationships between elements, not positions
on the grid. Think "A must reach B" not "A must reach row 38." If your
hypothesis includes a specific coordinate as part of the goal, it is wrong --
restate it in terms of what must relate to what.
Render the grid and read it as a picture.

Forming good hypotheses: When something interesting happens, don't just note the
  event -- note what else was true at that moment. What were other elements doing
  relative to each other? The relationship between elements is often the actual rule.
  Never trust a hypothesis based on a single observation. Reproduce the effect from
  a different starting state to separate the actual rule from coincidences of that
  particular configuration.

You are the THEORIST. The orchestrator calls you once before each acting turn
to propose hypotheses for HOW TO CLEAR THIS LEVEL -- your reasoning is folded
into the trace so the skill-miner and the judge can see whether a skill
ADVANCES a hypothesis you named (vs repeating an exhausted one).

Read the trace + memories. Propose 2-3 concrete HYPOTHESES for how to CLEAR
THIS LEVEL -- mechanic-based, NEVER absolute coordinates. Each hypothesis is one
testable sentence: name the MECHANIC and the OBSERVATION that would confirm or
refute it. Mark any hypothesis the memories show was already tried with no goal
change as EXHAUSTED, and prefer a structurally different one.

YOU MUST NOT call spawn_agent, submit_action, eval/exec/subprocess.

EVIDENCE PROTOCOL (mandatory):
  ...
  2. Ground each candidate in `evidence`: >=10-word verbatim quotes from
     memory.details or trace_digest lines.
  3. Write task-agnostic, coordinate-free skills: never reference a task
     name, a level number, or a grid coordinate -- the judge scores these as
     grounding failures.

@dataclass(slots=True, frozen=True)
class Skill:
    skill_id: str                                  # stable UUID4
    summary: str                                   # one-line description
    recipe: str                                    # when->do->expect->verify->avoid
    evidence: list[str]                            # memory-id / trace 인용 참조
    posterior: tuple[int, int]                     # (confirm_n, falsify_n) Beta-style counts
    applicability_conditions: list[str]            # acting-time 적용 전제조건
    parent_hypothesis_ids: list[str]
    category: str                                  # mechanic|strategy|metacognitive|meta_skill|heuristic|invariant
    quarantined: bool = False
    quarantine_reason: str | None = None
    timestamp: datetime
    origin_task / origin_run_id                    # 크로스-게임 계보 추적
    retrieval_labels: tuple[str, ...]              # 검색자-어휘 라벨 (T3)
    posterior_by_game: dict                        # 게임별 confirm/falsify 분리 (T7)
    provenance: Provenance                         # scope 사다리: level|game|family|universal

def is_surviving(self, *, game: str | None = None) -> bool:
    # A skill survives the episode boundary iff:
    #   * not quarantined
    #   * confirm_n > falsify_n   (positive net evidence)
    #   * confirm_n + falsify_n >= 3   (minimum support, one-shot promotion 방지)
    c, f = post
    return (not self.quarantined) and (c > f) and (c + f >= 3)

skills.confirm("3f2a...", evidence_ref="mem_a1b2c3d4")
# skills.jsonl에 append되는 레코드(요약):
{"skill_id": "3f2a...", "summary": "...", "posterior": [3, 1],
 "posterior_by_game": {"ft09": [2, 0]}, "quarantined": false,
 "scope": "game", "provenance": {...}, "op": "confirm", ...}

@dataclass(frozen=True, slots=True)
class JudgeScore:
    advantage: float = 0.0    # 0..1 -- dIG(edit | library, memories, trace)
    grounding: float = 0.0    # 0..1 -- claims evidence-checked vs trace/memories
    combined: float = 0.0     # advantage x grounding, __post_init__에서 재계산(LLM 보고값 무시)
    weaknesses: str = ""      # single strongest doubt -- miner의 rewrite gradient (텍스트)
    direction: dict = ...     # {mode: "exploit"|"explore", sign: +1|-1, ...} 다음 스텝 방향

    def __post_init__(self):
        object.__setattr__(self, "combined",
            float(self.advantage) * float(self.grounding))

MODE-CONDITIONED SCORING -- advantage is PROGRESS-CONDITIONED on a CONCRETE
proxy: reaching a NOVEL (unseen) state. Stuck play has 0 level-ups, so a novel
state stands in for level progress; ...
  EXPLORE -- advantage means expected NEW information; weigh novelty above
    coverage; ... The probe earns HIGH advantage only when it is an
    untried move TOWARD a NOVEL (unseen) state ...
  EXPLOIT -- advantage means compression delivered; weigh coverage (how many
    observations it absorbs) above novelty; ... compressing a pattern
    that keeps the agent in the SAME state -- churn ... is LOW advantage
    no matter how consistent it is.