# Operator 02 — Self-application (Stage-0 template)

**Operator.** Self-application: take a prime P and apply P to **the machinery that sustains P**, or
to **P itself**, and ask whether the result is a *distinct* prime one level up. Two routes, run in
a SINGLE pass (the model tags which route it used — do not run them as separate sub-flavor
batches; unlike dualization's 1a/1b/1c the routes share one instruction and one output contract):

- **Route R · reflexive** — apply P to its own output/instance. (learning → learning-to-learn;
  abstraction → abstraction-of-abstractions; a preference over one's own preferences.)
- **Route M · machinery** — apply P to the process that produces or governs P. (incentive design →
  the incentives of the incentive-designer; a norm that enforces norm-enforcement; the review
  that reviews the reviewers.)

The characteristic non-result is the **fixed point** (P∘P ≈ P), which is itself *audit signal*
(a fixed point flags a maximally-general "top" prime — recursion, reflexivity, identity), not
merely a failure. Fixed points are persisted, not discarded (§B.1, §E).

**What this template is for.** Stage-0 of the pipeline in `OPERATOR_SEARCH_RUNBOOK.md`. It holds
(A) the crank prompt, (B) the collapse test, (C) the few-shot calibration set, (D) the pilot
procedure, (E) notes. Freeze it; every Stage-2 batch uses §A verbatim so payloads stay
cache-friendly. It inherits op-01 v4.2 / op-05 v2 machinery wholesale (protection rule,
deterministic slug check, retrieval-grounded cheap check, INPUT-line contract +
block-count reconciliation) and adds one operator-specific device: the **LEVEL2 rule** (§A), the
self-application analog of op-05's sibling-evidence rule.

**Model tier (decided at build, confirmed by pilot).** Stage 2 runs on **sonnet**, not haiku.
Rationale mirrors op-05's capability-floor finding: distinguishing a genuine second-order prime
from (i) a fixed point and (ii) vacuous "meta-X" restacking requires holding the base level AND
the meta level in mind simultaneously and checking that new structure appears at the meta level —
exactly the "hold the input plus its relatives at once" move haiku failed on op-05. A 15-prime
haiku probe runs alongside the pilot purely as a floor datapoint; the gate is scored on sonnet.

**Status 2026-07-03 (v1.1 — PILOTED, GATE PASS with the rescue rule).** Pilot on the frozen
53-sample + 2 injected holdouts (55 apps, sonnet Stage 2, + 15-prime haiku floor probe).
**Stage-2 verdicts: 0 NEW / 40 COLLAPSE / 15 FIXED_POINT.** Funnel → 15 survivors (27%) → 6 holds
(2 STRONG: `evolvability`, `second_order_preference`; 4 moderate/weak: `meta_learning`,
`structural_stability`, `model_uncertainty`, `meta_decision`) + 4 balanced-granularity alias
confirmations (mechanism_design, normativity, regulatory_capture, leverage_points self) + 15
fixed-point audit rows. **Gate: PASS — but ONLY with the v1.1 articulated-candidate rescue rule
(§B.4a below), which is load-bearing and the op-02 keystone.** Without it `second_order_preference`
dies silently at Stage 2. Details: `../manifest_op02_pilot.yaml`, `crank/op02_pilot.jsonl`.

**THE OP-02 KEYSTONE FINDING (bake into every op-02 run).** Stage-2 VERDICT is untrustworthy from
BOTH tiers in OPPOSITE directions: sonnet OVER-collapses genuine second-order primes as "mere
iteration" (because a second-order prime always references its base — the self-application analog
of op-05's retrieval-proximity fallacy); haiku OVER-produces NEW as vacuous meta-slogans. So the
funnel must NOT gate on Stage-2 NEW. Keep sonnet at Stage 2 (its FIXED_POINT/alias calls are sound
and it doesn't flood the funnel with meta-fluff), but treat the verdict as advisory and rely on
step-0 alias verification + the articulated-candidate rescue + Stage-4 frontier.

Few-shot/holdout targets verified against the frozen 1,325 corpus: `metanorm` ABSENT,
`metaplasticity` PRESENT, `evolvability` ABSENT, `second_order_preference` ABSENT,
`meta_learning`/`learning_to_learn` ABSENT (metacognition is distinct), `structural_stability`
ABSENT. Meta-landing-zone primes that correctly absorb many applications as aliases:
`metacognition`, `second_order_cybernetics_second_order_observation`, `metasystem_transition`,
`reflexivity_self_reference`, `higher_order_function`, `bootstrapping`, `metaplasticity`,
`recursion`, `self_organization`, `autopoiesis`.

**Status 2026-07-03 (FULL-CORPUS SWEEP COMPLETE / RETIRED).** Kurt authorized the full sweep after
the pilot gate pass. 1,325 sonnet Stage-2 apps → 207 NEW (16%) / 582 COLLAPSE / **536 FIXED_POINT
(41% — op-02 is the highest-fixed-point operator, confirming companion §6)** → funnel → 526
survivors → 12 sonnet Stage-4 batches → frontier. **~10 STRONG canonically-named holds** ranked by
cross-input convergence (second_order_preference ×5, metanorm ×4, meta_learning/structural_stability/
evolvability ×2, + meta_optimization/second_order_uncertainty/second_order_probability/
recursive_theory_of_mind/kompetenz_kompetenz) + ~5 moderate + 95 alias confirmations + ~490 Tier-B
coinage holds (bulk). 8 stubs written. Manifests: `../manifest_op02_pilot.yaml`,
`../manifest_op02_sweep.yaml`, `s4/shortlist.md`. **SECOND KEYSTONE (Stage-4):** the §D amendment
makes sonnet Stage-4 OVER-HOLD (grants a HOLD to nearly every mechanical X-of-X); the discriminator
that separates genuine second-order primes from coinage noise is **cross-input convergence +
canonical-name presence** — rank Stage-4 survivors by these and auto-Tier-B the single-route
un-named coinages. Corpus frozen 1,325; finds accumulate for owner end-of-search curation.

---

## A. The crank prompt (Stage 2 — sonnet, batched)

> You are applying a single, precise transformation called **SELF-APPLICATION** to entries from a
> catalog of "prime abstractions" — domain-general structural patterns of thought.
> Self-application turns a prime P on **itself** or on **the machinery that sustains P**, and asks
> whether that produces a *distinct* second-order prime, one genuine level up.
>
> Pick whichever route fits the input (tag it in ROUTE):
> - **R (reflexive):** apply P to its own output or to an instance of P. Examples of the shape:
>   learning about how one learns; an abstraction whose instances are themselves abstractions; a
>   preference concerning one's own preferences.
> - **M (machinery):** apply P to the process that produces, selects, or governs P. Examples of
>   the shape: the incentives faced by whoever designs the incentives; a norm that governs the
>   enforcement of norms; the selection pressure acting on the capacity to generate variation.
>
> A valid self-application output is itself a **prime**: domain-general, structurally distinct,
> with its own second-order anatomy. It is NOT:
> - **a fixed point** — applying P to itself returns P essentially unchanged (recursion applied to
>   recursion is recursion; symmetry of a symmetry is symmetry). Output `VERDICT: FIXED_POINT`.
>   This is a real and useful result (it flags P as a maximally-general "top"), NOT a failure —
>   report it honestly rather than inventing a fake level-2.
> - **a mere iteration / restacking** — "meta-P" as a label with no NEW load-bearing structure at
>   the meta level; just doing P twice, or naming "P about P" without saying what is different one
>   level up (COLLAPSE — mere_iteration).
> - **a level-2 prime the catalog already names** under a slug you can actually name (COLLAPSE —
>   alias; report the slug in NEAREST — your claim WILL BE VERIFIED against the catalog, so never
>   collapse on the grounds that a slug "surely exists"; if you cannot name a specific slug, the
>   verdict is NEW).
> - **a narrow domain instance** of some other prime.
>
> **LEVEL2 RULE (load-bearing — the self-application analog of a sibling test): a genuine
> second-order prime must exhibit at least one structural feature that exists at the META level
> but NOT at the base level.** Name it in the LEVEL2 line — concretely, not as a slogan. If the
> only thing you can say is "the same as P but applied to P," there is no new structure: output
> COLLAPSE with REASON "no level-2 structure — mere iteration" (or FIXED_POINT if P∘P ≈ P).
> Worked contrast: *normativity → metanorm* is NEW because a metanorm has structure absent at the
> base — it punishes those who FAIL TO PUNISH violators (a second enforcement layer that can
> exist even when first-order enforcement is intact); *recursion → recursion* is FIXED_POINT
> because applying recursion to a recursive process yields nothing recursion did not already have.
>
> Think about the route and the level-2 structure, then decide. Bias toward COLLAPSE/FIXED_POINT:
> a false NEW is expensive downstream, a missed NEW is cheap (later sweeps get another shot). For
> EACH input below, output EXACTLY this contract and nothing else:
>
> ```
> INPUT:     <slug, copied from the payload line>
> ROUTE:     R | M
> CANDIDATE: <one sentence, domain-stripped, describing the second-order prime — or NONE>
> LEVEL2:    <the structural feature present at the meta level but not the base — or NONE>
> NEAREST:   <slug of the closest existing prime you can name, or NONE>
> VERDICT:   NEW | FIXED_POINT | COLLAPSE
> REASON:    <=12 words>
> ```
>
> **Payload:** `P.slug` · `P.one_liner` · `P.core_idea` (~2 sentences) · `P.structural_signature`

**Batching.** ~25–27 payloads/batch, INPUT-line contract, hold the instruction block constant.
The harness counts output blocks against payload lines and re-asks any missing slug (op-01 lesson:
sub-agents silently drop 2–8% of payload rows). One route is NOT one batch — the model chooses
R or M per input.

**Stage-2 search discipline.** Instruct: do NOT use tools/search at Stage 2; rely on NEAREST-naming
discipline — every claim is verified downstream (matches op-05 batches).

---

## B. Collapse test (inherits op-01 v4.2 / op-05 v2 machinery; self-application specifics noted)

0. **Alias-claim verification (run FIRST, on every COLLAPSE/NEW that names a NEAREST).** Look the
   claimed NEAREST up in the slug list + alias map (normalized), then in the one_liner embedding
   screen. If it exists → alias COLLAPSE confirmed (keep as negative + balanced-granularity
   signal). If it does NOT exist AND the embedding screen finds no prime within alias distance →
   **reclassify as a clean-gap candidate and route to Stage 4** (the model named a level-2 prime
   so obvious it assumed the catalog had it — the deterministic gap path). Fuzzy/substring slug
   matches are menu-hints only, never auto-verification.

1. **Fixed-point collapse (self-identity) — OPERATOR-CHARACTERISTIC, retained as audit signal.**
   `VERDICT: FIXED_POINT` (or CANDIDATE≈input by the one_liner cosine backstop, ≥0.80) →
   **do not discard.** Append a row to `workspace/operator_search/audit_self_duals.jsonl` with
   `{input, operator: "02_self_application", route, source: "stage2_verdict", reason}`. Two species
   to note in `reason` where the model distinguishes them: *idempotent* (P∘P = P by P's own
   nature — symmetry, closure, identity) vs *maximal-generality top* (P already sits at the top of
   its meta-tower — recursion, reflexivity_self_reference, abstraction). Both are structural facts
   about the corpus (companion §6). A fixed point is never routed to Stage 4.

2. **Alias collapse (level-2 prime already in corpus).** Self-application lands in the corpus's
   meta-zone often (metacognition, second_order_cybernetics, metasystem_transition,
   reflexivity_self_reference, higher_order_function, bootstrapping, metaplasticity). Handle exactly
   as op-01 §B.2: lexical check first (the model usually names the level-2 pole), then the
   **retrieval-grounded cheap-model check** — candidate + top-6 one_liner-space neighbors menu →
   `ALIAS_OF` (must be copied from that item's menu) / `NOT_A_PRIME`. **Defanged labels, op-02
   wording:**
   - `mere_iteration` = "meta-P" with no new level-2 structure — just P applied twice, or a label
     with no distinct anatomy. (This is op-02's analog of op-05's `restatement`/`overgeneral`.)
   - `absence` = a level merely switched off, no anatomy of its own.
   - `domain_instance` = one field's narrow case of a general second-order pattern.
   - **A genuine second-order prime whose base is the nearest corpus entry is NOT `mere_iteration`
     just because it references its base** — describing the meta level of P's own tower is exactly
     what a valid self-application does. The discriminator is the LEVEL2 line, NOT retrieval
     proximity (see §D amendment — inherited from the op-05 retrieval-proximity fallacy).

   ```
   ITEM:        <number>
   ALIAS_OF:    <one slug copied from that item's menu, or NONE>
   NOT_A_PRIME: <mere_iteration | absence | domain_instance | NONE>
   WHY:         <=10 words>
   ```

3. **Protection rule (v4/v4.1 — load-bearing).** No `ALIAS_OF` or `NOT_A_PRIME` kill (and no
   Stage-2 self-collapse or FIXED_POINT verdict) may retire a candidate's LAST live route if the
   candidate is (a) proposed by ≥2 inputs this sweep (same level-2 concept reached from different
   bases — strong convergence, e.g. many primes lifting to metacognition/metanorm), or (b) already
   present in any `manifest_*` as accept/hold. Such candidates route their best-phrased variant to
   Stage 4 regardless of the cheap verdict. **Note the op-02 twist:** a FIXED_POINT is a legitimate
   *terminal* verdict for a top prime and does NOT need Stage-4 rescue on its own — protection
   applies only when a *different* route/input proposes a genuine level-2 for the same concept, or
   the concept is manifest-known. Do not let a single sonnet FIXED_POINT call silently kill a
   convergent NEW.

4. **Not-a-prime collapse.** Trust a sonnet COLLAPSE citing `mere_iteration` / `domain_instance` /
   `absence` ONLY under the rescue rule in 4a; step-0 still verifies any NEAREST it names.

4a. **Articulated-candidate rescue rule (v1.1 — the op-02 keystone; validated in the 2026-07-03
   pilot as load-bearing for zero silent deaths).** A COLLAPSE labelled `mere_iteration` /
   "no new anatomy" is trusted (killed) ONLY when `CANDIDATE: NONE` AND `LEVEL2: NONE`. **If the
   Stage-2 model wrote a SUBSTANTIVE `CANDIDATE` (named a real second-order structure) but stamped
   it `mere_iteration`, route it to Stage 4 regardless of the verdict.** Rationale: a genuine
   second-order prime ALWAYS references its base, so "it just restates P applied to P" is exactly
   the over-collapse fallacy (the self-application analog of op-05's retrieval-proximity fallacy);
   the new-vs-iteration call is a frontier judgment and the discriminator is the LEVEL2 line, not
   whether the candidate names its base. In the pilot this is the ONLY mechanism that saved
   `second_order_preference` (substantive CANDIDATE, blank LEVEL2, `mere_iteration`, NEAREST=NONE —
   invisible to both alias verification and convergence protection). `FIXED_POINT` with
   `CANDIDATE: NONE` stays a fixed point (audit row); it is not rescued.

5. **Deterministic slug-existence check (v4.2)** on every SLUG the Stage-4 pre-adjudicator proposes
   (slug list + alias map, normalized) BEFORE frontier review. Semantic search verifies *concept*
   absence; only the lexical lookup verifies *name* absence — both required. Each catch is a free
   balanced-granularity confirmation. (op-01 caught 5 already-present primes this way.)

**Calibration target (pilot, corpus-state-aware). Zero silent deaths.**
- `metanorm` (from normativity) — verified ABSENT → must surface NEW or step-0 clean-gap, reach
  Stage 4.
- `evolvability` (from natural_selection, holdout) — verified ABSENT → must reach Stage 4.
- `second_order_preference` (from preference, holdout) — verified ABSENT → must reach Stage 4.
- `metaplasticity` (from hebbian_learning if sampled; else the general "learning-to-learn" lift) —
  PRESENT → must resolve as a *verified* alias COLLAPSE naming it (a PASS + balanced-granularity
  confirmation).
- `recursion`, `reflexivity_self_reference`, `symmetry`, `closure` self-applications → must land as
  FIXED_POINT (audit rows), NOT forced into fake level-2 primes.

---

## C. Few-shot calibration set (v1)

Solved exemplars go in the §A prompt; holdouts stay held out for scoring. Score corpus-state-aware.

**Exemplar 1 — route M, NEW — SOLVED (few-shot):**
```
INPUT:     normativity
(payload: normativity · "shared standards that make actions correct or incorrect, licensing praise, blame, and correction" · [rule + evaluation + sanction])
ROUTE:     M
CANDIDATE: A second-order norm that sanctions those who fail to sanction first-order violators — enforcement of enforcement.
LEVEL2:    a punishment target (the non-punisher) that does not exist at the base norm's level; sustains cooperation when first-order enforcement decays
NEAREST:   NONE
VERDICT:   NEW
REASON:    metanorm (Axelrod); the norm-that-enforces-norms was absent
```

**Exemplar 2 — route R, alias COLLAPSE — SOLVED (few-shot):**
```
INPUT:     hebbian_learning
(payload: hebbian_learning · "connections strengthen when linked units co-activate" · [local correlation-driven weight change])
ROUTE:     R
CANDIDATE: NONE
LEVEL2:    NONE
NEAREST:   metaplasticity
VERDICT:   COLLAPSE
REASON:    plasticity-of-plasticity already in corpus (alias)
```

**Exemplar 3 — FIXED_POINT — SOLVED (few-shot):**
```
INPUT:     recursion
(payload: recursion · "a process defined in terms of itself, applied to its own output" · [self-reference with base case])
ROUTE:     R
CANDIDATE: NONE
LEVEL2:    NONE
NEAREST:   recursion
VERDICT:   FIXED_POINT
REASON:    applying recursion to a recursive process yields nothing new — a top
```

**Exemplar 4 — mere_iteration COLLAPSE (counter-example) — SOLVED (few-shot):**
```
INPUT:     compression
(payload: compression · "represent information using fewer resources by exploiting redundancy" · [remove redundancy, preserve signal])
ROUTE:     R
CANDIDATE: NONE
LEVEL2:    NONE
NEAREST:   NONE
VERDICT:   COLLAPSE
REASON:    compressing a compressed stream is just compression again — mere iteration, no new level-2 structure
```

**Exemplar 5 — route R, NEW — HOLDOUT (score it, NOT in prompt):**
```
INPUT:     natural_selection
(payload: natural_selection · "heritable variants that reproduce better become more common" · [variation → selection → retention])
EXPECTED CANDIDATE ≈ selection acting on the capacity to generate adaptive variation itself — the evolution of evolvability.
EXPECTED LEVEL2 ≈ a second-order trait (mutation structure, modularity, robustness) that shapes FUTURE variation, invisible at the single-round selection level.
EXPECTED VERDICT:  NEW  (evolvability verified absent 2026-07-03)
```

**Exemplar 6 — route R, NEW — HOLDOUT (score it, NOT in prompt):**
```
INPUT:     preference
(payload: preference · "an ordering over options that guides choice" · [ranking + choice-guidance])
EXPECTED CANDIDATE ≈ a preference whose objects are one's own first-order preferences — endorsing or wanting to change what one wants.
EXPECTED LEVEL2 ≈ the object is itself a preference; enables internal conflict, self-endorsement, and willed change absent at the base ordering (Frankfurt second-order desires).
EXPECTED VERDICT:  NEW  (second_order_preference verified absent 2026-07-03)
```

---

## D. Pilot procedure (v1)

1. **Sample.** Frozen `../pilot_sample.jsonl` (53 rows) + inject exemplar-5 (`natural_selection`)
   and exemplar-6 (`preference`) if absent from the sample → ~55 apps. (The sample already
   contains many self-application-relevant primes: infinite_regress, compositionality, closure,
   modal_reasoning, conceptual_blending, transfer_of_learning, leverage_points.)
2. **Stage 2 on sonnet** (2 batches, §A prompt verbatim + exemplars 1–4). Run a **15-prime haiku
   probe** on the same payloads in parallel — floor datapoint only; not scored for the gate.
3. **Stage 3–4 with the §B machinery:** step-0 alias verification → lexical → retrieval-grounded
   cheap check (defanged labels) → protection rule (incl. Stage-2 self-collapses/FIXED_POINTs) →
   deterministic slug check → sonnet Stage-4 pre-adjudication → frontier shortlist review.
4. **Fixed-point handling:** every FIXED_POINT verdict → audit row (§B.1). Report the count and the
   idempotent/top split; these are a deliverable, not noise.
5. **Score holdouts + metanorm corpus-state-aware** (§B calibration target). Record: NEW-rate,
   FIXED_POINT-rate, route split (R vs M), batch-to-batch NEW variance, step-0 reclassification
   count, survivor rate, cost-per-accepted-prime after a quick Stage-4 pass, and the haiku-vs-sonnet
   delta on the 15-prime probe (confirms/refutes the tier decision).
6. **Decision gate (inherits op-01 v4):** (i) every live holdout + every manifest-known candidate
   resolves correctly — **zero silent deaths** (protection rule enforces this); (ii) Stage-4
   cost-per-accepted-prime acceptable to owner. The ≤5% survivor-rate target is retired.
7. On gate pass, authorize the full 1,325 sweep (payloads = `../worklist_dualization.jsonl`, which
   already carries slug/one_liner/core_idea/signature for every prime; re-tag `operator:
   02_self_application`). Corpus frozen at 1,325 (owner decision 2026-07-03) — finds accumulate as
   manifest rows + `v2_density_pilot` stubs for end-of-search batch curation.

**§D AMENDMENT (mandatory for op-02 Stage 4 — inherited from op-05's hard-won lesson).** When the
genus/level-2 is absent, **the input is ALWAYS the nearest corpus entry to its own second-order
prime** — so "the input itself is the top search hit" is NOT evidence of restatement/mere_iteration.
The discriminator is the **LEVEL2 line**: is there load-bearing structure at the meta level that
the base lacks? Sonnet Stage-4 must be told this explicitly, or it blanket-zeros genuine finds via
the retrieval-proximity fallacy (op-05 lost ~40% of real holds to it before the frontier override).

---

## E. Notes & watch-items

- **Fixed points are the primary deliverable of the audit, not the failure mode.** Op-02 is
  expected to be the highest-fixed-point operator in the whole program (many primes are already at
  the top of their meta-tower). A low NEW-yield is NOT a failed operator if the fixed-point census
  is populated — it is a structural map of which corpus primes are maximal generalizers.
- **Overlap with generalization (op-05) and interpolation.** "learning → learning-to-learn" is
  both a self-application (R) and arguably a lift. Convergence across operators is *signal*; Stage 3
  merges duplicates. Do not force a clean boundary; log the overlap in the manifest.
- **Meta-zone density is a granularity check, not a bug.** A high alias rate onto metacognition /
  second_order_cybernetics / metasystem_transition confirms the corpus already carved the meta
  layer well. Log each as a balanced-granularity confirmation.
- **Route M is where the genuinely-new primes concentrate** (the machinery route reaches structures
  like metanorm, the-incentives-of-incentive-designers, the-selection-on-variation that base-level
  mining rarely names). Route R more often lands on fixed points or existing meta-zone aliases.
  Watch the route split as a yield predictor.
- **Framed primes give noisier self-applications** (as with every operator): a framed prime's
  "meta" version is often another framed instance. Expect higher COLLAPSE in the framed stratum.
