# Operator Search Runbook — Systematic Prime Discovery by Operator Sweep

**Purpose.** The operational process for discovering new prime abstractions by applying a closed
set of **operators** (transformations that take existing prime(s) and propose a candidate prime)
across the corpus, screening the outputs cheaply, and adjudicating only the survivors. Designed
for a **small token budget run over months** — the architecture, not the spend, does the work.

**Companion docs (read alongside):**
- `workspace/07_operator_prime_discovery.md` — the concepts, foundations, and novelty analysis
  (read this first; it explains *why* the pipeline is shaped this way).
- `workspace/OPERATOR_SEARCH_FINDINGS.md` — the living **findings & synthesis** doc: results of
  running the search, the per-operator ledger, the saturation gradient, and the hard-won method
  lessons. Extend it after each search (seed for the eventual publication).
- `workspace/phase_c_outputs/_emergent_new_primes.yaml` — the reactive precursor; the emergent
  primes are prior outputs of operators 5/12/13 run by hand. Reuse its draft standard.
- `CLAUDE.md` (repo root) — the `one_liner` sync rule; any accepted prime needs it.
- Existing prime-drafting standard: `prime_abstractions/v2_density_pilot/random_walk.md` and
  `non_locality.md` (canonical template for a new candidate's frontmatter + sections).

**Status 2026-07-02 (pilot #1 + v2 re-pilot both run).** Dualization piloted twice on the frozen
53-prime sample (`workspace/operator_search/`). **Yield pending owner curation: 1 accept
(`eager_evaluation`) + 7 holds** (heterarchy, sloppy_parameters, expansion_unpacking,
multiple_realizability, negative_transfer, decision_paralysis, common_mode_failure — last three
new in the v2 run). Template v2 fixed the miscalibrations pilot #1 found: holdout scoring is now
a clean sweep (zero silent deaths; step-0 alias-claim verification is the load-bearing fix), and
the pure embedding alias screen is retired in favor of a retrieval-grounded cheap-model check
(no separating cosine threshold exists — bge signal weak). **v4 ADOPTED 2026-07-02 (owner decision)** after v1 pilot → v2 re-pilot → v3 validation (gate
fail: `restatement` label killed genuine duals) → defang trial. Template
`workspace/operator_search/templates/01_dualization.md` now carries: defanged restatement
wording, the convergence/manifest **protection rule** (no cheap-check kill of a known-good or
2-flavor-convergent candidate's last route), and **sonnet-batched Stage-4 pre-adjudication**
(frontier reviews the shortlist only). **Gate re-based by owner: zero silent deaths of
known-good candidates + Stage-4 cost-per-accepted-prime** — the ≤5% survivor target is retired
(unreachable at cheap-check reliability; ~30% of applications reach Stage 4). **OPERATOR 01 (DUALIZATION) SWEEP COMPLETE 2026-07-03** — all three flavors run over the full
corpus (3,973 applications; template v4.1 with Stage-2 protection rescue). Cumulative yield
pending owner curation: **6 accept-recommendations** (eager_evaluation, risk_seeking,
confabulation, pareidolia, hold_up_problem, consequentialism) **+ ~25 holds** + convergence-
strengthened earlier holds (heterarchy ×3 routes, foundationalism ×3, common_mode_failure ×2,
negative_transfer ×3, brittleness ×2) + a double lattice gap (consequentialism/deontology beside
virtue_ethics) + 9 balanced-granularity confirmations + ~1,250 training negatives.
Zero-silent-deaths gate PASS on all three sweeps. Total ≈ 6.9M subagent tokens ≈ 0.22M per
accept-or-new-hold. Manifests: `manifest_dualization*.yaml`, `manifest_sweep_1a.yaml`,
`manifest_sweep_1bc.yaml`; curve table `SATURATION.md`. Drafting still deferred; corpus 1,325.

**OPERATOR 13 RUN + RETIRED and OPERATOR 05 (generalization) FULL-CORPUS SWEEP COMPLETE
2026-07-03** — see SATURATION.md (op-13: 0 new + 12 DAG-gap edges; op-05: ~47 holds + 259
missing-edge flags across pilot/framed/structural strata, framed stratum is the yield engine).

**OPERATOR 02 (self-application) FULL-CORPUS SWEEP COMPLETE / RETIRED 2026-07-03.** Template
`templates/02_self_application.md` (v1.1); two routes (R reflexive / M machinery) in one pass;
fixed-point collapses persisted to `audit_self_duals.jsonl` (560 rows: 24 op-01 + 536 op-02).
Pilot GATE PASS (55 apps, sonnet + haiku floor probe) → Kurt authorized the full sweep
(AskUserQuestion 2026-07-03). Full sweep: 1,325 sonnet Stage-2 apps → **207 NEW (16%) / 582
COLLAPSE / 536 FIXED_POINT (41% — op-02 confirmed the highest-fixed-point operator per companion
§6)** → funnel → 526 survivors → 12 sonnet Stage-4 batches → frontier shortlist. **Yield: ~10 STRONG
canonically-named second-order primes** (all verified absent), 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. **8 stubbed** in v2_density_pilot/;
**95 balanced-granularity alias confirmations**; **~490 Tier-B mechanical coinage holds** bulk-listed
(op-05 Tier-B precedent; latent DAG-composition signals). Manifests: `manifest_op02_pilot.yaml`,
`manifest_op02_sweep.yaml`, `op02/s4/shortlist.md`. **Keystone method findings:** (1) Stage-2
verdict untrustworthy from BOTH tiers in opposite directions (sonnet over-collapses genuine
second-order primes as "mere iteration" = the self-application analog of op-05's retrieval-proximity
fallacy; haiku over-produces vacuous meta-slogans) → funnel gates on step-0 + the
**articulated-candidate rescue rule** (§B.4a) + Stage-4, never Stage-2 NEW; (2) at Stage-4 the §D
amendment makes sonnet OVER-HOLD → the real discriminator is **cross-input convergence +
canonical-name presence**. Cost ≈ 1.9M sonnet tokens ≈ 0.19M per strong hold.

**OPERATOR 03 (temporalization) FULL-CORPUS 3-FLAVOR SWEEP COMPLETE / RETIRED 2026-07-03.** Template
`templates/03_temporalization.md` (v1); 3 flavors (3a level→flow, 3b state→trajectory, 3c
present→anticipation); already-temporal fixed points → `audit_temporalization.jsonl` (788 rows).
Pilot GATE PASS → Kurt authorized the full 3-flavor sweep (AskUserQuestion). **Tier decision: HAIKU
Stage 2** (12/15 pilot agreement with sonnet; mechanical axis-add like dualization; funnel gates
downstream). 3,971 haiku apps → funnel → **1,450 fixed points / 1,258 survivors / 357 alias
confirmations** → 660 prioritized → 15 sonnet Stage-4 batches. **Primary deliverable is AUDIT: an
788-prime already-temporal census (59% of the corpus is inherently dynamic) + 357
balanced-granularity confirmations** — a strong statement the corpus's dynamic layer is near-complete.
**Discovery yield small (companion §6 confirmed): 1 STRONG convergent find `transient_response`
(×12 inputs) + 4 moderate (`critical_slowing_down`, `overshoot`, `predictability_horizon`,
`phase_synchronization`); 5 stubbed.** ~600 Tier-B "rate-of-X" coinages bulk-listed. Cost ≈ 2.8M
haiku + 0.5M sonnet (cheapest operator so far, thanks to the haiku tier). Manifests:
`manifest_op03_sweep.yaml`, `op03/s4/shortlist.md`.

**OPERATOR 04 (spatialization/scaling) FULL-CORPUS 3-FLAVOR SWEEP COMPLETE / RETIRED 2026-07-03.**
Template `templates/04_spatialization.md` (v1); 3 flavors (4a point→field, 4b discrete↔continuous,
4c micro→macro); already-spatial fixed points → `audit_spatialization.jsonl` (495 rows). Pilot GATE
PASS → Kurt authorized the full 3-flavor sweep (Option 1). **TIER: SONNET** (pilot haiku probe only
5/15 agreement with sonnet vs op-03's 12/15 — spatialization needs judgment). 3,975 sonnet apps →
funnel → **716 fixed points / 1,016 survivors / 200 alias confirmations / 2,043 rejects** → 591
prioritized → 14 sonnet Stage-4 batches. **Primary deliverable is AUDIT: a 495-prime already-spatial
census (37% of corpus — less saturated than op-03's 59%) + 200 confirmations.** **Discovery: 3
STRONG — `field` (genus convergence of hundreds of "field of P" inputs → the missing general field
prime), `mean_field` (×3), `continuous_relaxation` (×2) — + 3 moderate (`spatial_random_field`,
`continuum_limit`, `density`).** 5 stubbed. ~1,000 Tier-B coinages bulk-listed. Cost ≈ 4.5M sonnet
(the most expensive unary operator — sonnet tier). Manifests: `manifest_op04_sweep.yaml`,
`op04/s4/shortlist.md`.

**OPERATOR 06 (modalization) FULL-CORPUS 3-FLAVOR SWEEP COMPLETE / RETIRED 2026-07-03.** 3 flavors
(6a actual→possible, 6b deterministic→stochastic, 6c mandatory→default); already-modal fixed points →
`audit_modalization.jsonl` (297 rows). Pilot GATE PASS → Kurt authorized the full sweep (Option 2).
**TIER: SONNET** (pilot haiku 7/15 — marginal). 3,975 apps → **350 fixed points / 882 survivors /
407 alias confirmations / 2,336 rejects**. **Modal axis LEAST-saturated at fixed-point level (22%
already-modal) but heavily alias-covered (407).** **Smallest domain-general yield: 4 holds —
`possibility` (STRONG genus convergence), `defeasibility` (×6), `deontic_modality`, `expected_value`
(fold-flagged vs present expected_utility); 4 stubbed.** ~9 domain-specific → deferred backlog
(task #19). ~800 Tier-B coinages bulk. Cost ≈ 4.5M sonnet. `manifest_op06_sweep.yaml`,
`op06/s4/shortlist.md`.

**OPERATOR 08 (threshold/phase) PILOT-ONLY → RETIRED AS SATURATED 2026-07-03.** Template
`templates/08_threshold.md` (v1); 2 flavors (8a gradual→tipping, 8b continuity→discreteness — 8b
duplicates op-04 4b). The pilot doubled as a saturation check (per §D.5) and confirmed near-zero
yield: 8a 2 NEW/53 (both non-genuine — a Shannon coinage + an alias to op-03's `phase_synchronization`
stub); 8b 0 NEW/53 (pure op-04 redundancy). The threshold/phase region is already complete in the
corpus (tipping_points, threshold, percolation_threshold, critical_mass, nucleation, hysteresis,
symmetry_breaking, regime_change, metastability, punctuated_equilibrium, cascade, ...). **RETIRED
without a full sweep** (§8: stop early on saturation; saved ~4M sonnet), like op-13. The 2 genuine
domain-general gaps captured as stubs: **`catastrophe`** (Thom/Zeeman geometry) + **`order_parameter`**
(Landau). Notes: `bifurcation` absent-but-aliased-to-tipping_points (possible owner split);
`critical_exponent` → domain-specific backlog (task #19). `manifest_op08_threshold.yaml`,
`audit_threshold.jsonl` (19 fixed points). Cost ≈ 0.16M sonnet (pilot only).

**OPERATOR 07 (perspective inversion) PILOT-ONLY → RETIRED AS SATURATED 2026-07-03.** Template
`templates/07_perspective_inversion.md` (v1); SINGLE pass (swap to the complementary seat — not
sub-flavors). Verified at build that the corpus already names both seats of every canonical
relational pair + the perspective meta-primes, so op-07 was expected saturated; the pilot (53 apps,
sonnet, haiku probe 12/15) confirmed: **1 NEW/53 (a framed critical-theory construct), 8 alias
confirmations, 7 symmetric fixed points, 37 rejects** → **RETIRED without a full sweep** (§8), like
op-08/op-13. Lone find stubbed: **`interpellation`** (subject/addressee seat of grand_narrative;
flagged framed). Cost ≈ 0.14M. `manifest_op07_perspective.yaml`, `audit_perspective.jsonl`.

**ALL UNARY OPERATORS COMPLETE** (1–8) + 13 cluster. **N-ARY PHASE STARTED. OPERATOR 12
(interpolation) RUN → RETIRED AS SATURATED 2026-07-03.** Pre-filtered worklist = 61 subsumption edges
with cos(parent,child)<0.65 (`op12_worklist.json`); sonnet, 2 batches. **0 genuine new intermediates**
(all 4 "NEW" were child-restatements or an existing prime) — the DAG is tight (0 edges cos<0.5), so
there's no room; confirms project-06/op-13 reactive exhaustion. Byproduct: 13 missing-edge
DAG-densification flags + 13 mis-parent flags (`op12/byproduct.json`). Token reading: ~1.24K/app
(compact 2-prime payloads — cheaper than the ~2K planning estimate). `manifest_op12_interpolation.yaml`.

**Combinatorial phase plan (pre-filter counts computed 2026-07-03).** Remaining n-ary operators and
their pre-filtered candidate-set sizes: **op 9 composition** = archetype-co-occurring ∩ embedding-close
(~1,100 at cos>0.75, ~4,000 at cos>0.7); **op 10 tension-resolution** = named tensions (~1,400 prime
`structural_tensions`, filter to opposed pairs, ~300–1,400); **op 11 analogy completion** = the
operator-confirmed pairs we accumulated (~200–500); **op 14 lattice/symmetry** = ~dozens of product
SPACES (structural analysis, not a pair sweep). At ~1.0–1.5K/app the phase totals ~3–10M, dominated by
op-9/op-10, all pilot-gated. **Owner order: op-12 (done) → op-11 (done) → op-10.**

**OPERATOR 11 (analogy completion) FULL 1,325 SWEEP COMPLETE 2026-07-04 — the ONLY n-ary operator
with genuine yield.** A:B::C:D cross-relational completion, EXCLUDING single-operator re-runs (that
filter is what makes it distinct from the axis-sweeps). Pilot (53) found 3 → Kurt authorized full
1,325 → 12 NEW / 1,305 COLLAPSE → **7 genuine domain-general finds** (ergodicity STRONG, allostasis
STRONG, coherentism, generativity, boundary_object ×2-convergent, construal_level; + envy_freeness/
rate_distortion/ROC/implementation_gap → domain-specific backlog). All 7 stubbed. Full-corpus rate
0.9% (<< the sample's 6% — the stratified sample over-represented relational primes) but the finds
are the high-value DIAGONAL primes no single axis-move reaches. Surfaced a regress-response lattice
gap (foundationalism+coherentism present, **infinitism absent**) → feeds op-14. Cost ≈ 1.4M sonnet
(~1.0K/app). `manifest_op11_analogy.yaml`, `crank/op11_full.jsonl`.

**OPERATOR 10 (tension-resolution) PILOT-ONLY → RETIRED AS SATURATED 2026-07-04.** Opposed pair →
resolution/synthesis prime. Pilot on frozen 53-sample (sonnet) = **0 NEW / 53** — completely
saturated. Collapse reasons: "generic balance" (resolution isn't a distinct prime), "dualization
re-run" (already swept in op-1), "already resolved by existing prime". The corpus already names its
tensions/dilemmas/tradeoffs + resolutions (risk_return_tradeoff, collingridge_dilemma, social_dilemma,
ambidexterity, jevons_paradox, dialectics, ...). Retired without a full run (§8). No stubs.
`manifest_op10_tension.yaml`. Matches op-08/12/13.

**OPERATOR 14 (lattice/symmetry completion) RUN 2026-07-04 — the 2nd n-ary operator with yield.**
Single opus frontier pass seeded with the 23 `_vs_` oppositions + known families → 15 candidate gaps
→ existence-check → **5 genuine cells stubbed**: `infinitism` (regress trilemma 3rd) + `cheap_talk`
(costless-signaling pole) STRONG; `common_pool_resource` (governance triad 3rd), `positional_good`
(value-frame 3rd), `type_iii_error` (framing-level error) MODERATE. `impossibility` noted for the
alethic family; `heterarchy` already an op-01 stub (convergence). Frontier self-rejected the
present/vacuous cells. Cost ≈ 0.04M. `manifest_op14_lattice.yaml`, `templates/14_lattice_completion.md`.

**OPERATOR 9 (composition) PILOT-ONLY → RETIRED AS SATURATED 2026-07-04 — THE LAST OPERATOR.**
Pre-filter = pairs sharing ≥3 archetypes with complementary similarity (0.45<cos<0.78) = 4,166 pairs;
diverse 88-pair pilot (per-prime cap 4). **0 NEW / 88** — tight co-occurring pairs are mere
conjunctions or already-named composites (natural_selection). Composition RECOMBINES existing primes,
so it saturated like op-10/12/13. 23 subsumption flags → edge harvest. `manifest_op09_composition.yaml`.

**★ THE FULL 14-OPERATOR SET IS COMPLETE (2026-07-04). ★** Whole-program yield law: an operator
yields only if it reaches a structural position NOT ALREADY IMPLIED by the corpus. Recombination /
fill-between operators (9 composition, 10 tension, 12 interpolation, 13 cluster) all saturated; only
analogy (11, diagonals) and lattice (14, empty symmetry cells) reached new ground. The unary
axis-operators (1–8) yield early (dualization, generalization, self-application), go audit-heavy in
the mid axes (temporal 59% / spatial 37% / modal 22% already-covered), and saturate at the ends
(threshold, perspective). **127 emergent-prime stubs** accumulated in `prime_abstractions/v2_density_pilot/`;
**corpus frozen at 1,325 throughout.** **The only remaining work is owner Stage-5 curation** of the
127-stub queue (+ the ~295-edge DAG-densification harvest + the deferred domain-specific backlog,
task #19). Program synthesis: `workspace/OPERATOR_SEARCH_FINDINGS.md`.

---

## 1. Definitions

- **Operator** — a function from a prime (unary) or a small tuple of primes (n-ary) to a
  *candidate* prime description. Fourteen operators, grouped in §2.
- **Application** — one (operator, prime) or (operator, prime-tuple) instance. The unit of work.
- **Candidate** — a one-sentence structural description output by an application.
- **Collapse** — an application whose output is not a new prime: it returns the input (fixed
  point), an existing prime (alias), or something that fails the prime bar. Collapses are
  **retained as signal** (audit + negative examples), not discarded — see §7.
- **Survivor** — a candidate that passes the cheap filters (Stages 2–3) and reaches frontier
  adjudication (Stage 4).

---

## 2. The operator set

Run each operator with its own prompt template (Stage 0). Sub-flavors share a template but are
prompted as separate passes.

### Unary — transform one prime along one axis

| # | Operator | Move | Sub-flavors (run separately) |
|---|---|---|---|
| 1 | **Dualization** | flip polarity | logical-negation · opposing-force · failure-mode |
| 2 | **Self-application** | apply P to the machinery that sustains P | (watch for fixed points) |
| 3 | **Temporalization** | add a time axis | level→flow · state→trajectory · present→anticipation |
| 4 | **Spatialization / scaling** | add extent/scale | point→field · discrete↔continuous · micro→macro (aggregation) |
| 5 | **Generalization (lift)** | strip a constraint or the domain frame | frame-strip (framed→structural parent) |
| 6 | **Modalization** | shift modal status | actual→possible · deterministic→stochastic · mandatory→default |
| 7 | **Perspective inversion** | read the same structure from another seat | sender/receiver · principal/agent · predator/prey |
| 8 | **Threshold / phase** | continuous→critical-point | gradual→tipping · continuity→discreteness |

### N-ary — combine primes (pre-filter the pair space — see §4, Stage 1)

| # | Operator | Move |
|---|---|---|
| 9 | **Composition** | P1∘P2 that co-occur so tightly the pair is an emergent unit |
| 10 | **Tension-resolution** | two opposed primes whose *resolution* (and the dilemma itself) may be primes |
| 11 | **Analogy completion** | A:B :: C:? — extrapolate the fourth term from an operator-related pair |
| 12 | **Interpolation** | given P1→P3 with a DAG edge and a large gap, propose the intermediate P2 |

### Catalog-internal — operate on the graph, not the primes

| # | Operator | Move |
|---|---|---|
| 13 | **Cluster-without-parent** | embed → cluster → find clusters with no common DAG ancestor → name the parent |
| 14 | **Lattice / symmetry completion** | in a natural product space (e.g. {fast/slow}×{reversible/irreversible}), find empty cells |

---

## 3. The pipeline (a funnel — cheap and wide first, expensive and thin last)

```
Stage 0  Formalize operator          one-time, frontier      per operator, reused for years
Stage 1  Enumerate applications      free, deterministic     no LLM
Stage 2  Cheap crank                 cheap model, batched    one line per application → cand | COLLAPSE
Stage 3  Dedup + alias screen        embeddings only         drop near-existing + merge near-dupes
Stage 4  Frontier adjudication       frontier, ~1–5% only    prime-bar test + v1 draft + justification
Stage 5  Owner curation             human                    provisional-hold vs accept
```

**Never spend a Stage-4 token on a candidate a Stage-3 embedding could have killed.** That rule
is the whole budget strategy.

---

## 4. Stage-by-stage procedure

### Stage 0 — Formalize each operator (one-time, frontier model)

For each operator, author and freeze:
1. **A prompt template** — takes the prime's `slug`, `one_liner`, `core_idea`, and
   `structural_signature`; instructs the model to apply exactly this one move; demands output in
   the fixed shape (see Stage 2).
2. **A collapse test** — the specific cheap check for this operator's characteristic non-result:
   - Dualization → does the output match an existing prime's embedding within alias distance?
   - Self-application → is the output semantically ≈ the input (fixed point)?
   - Generalization → is the proposed parent already an ancestor in the DAG?
   - (etc. — each operator's collapse mode is different; write it down once.)
3. **A worked example and a counter-example** in the prompt (few-shot), drawn where possible from
   the Phase-C reactive finds (e.g. dualization: injectivity→surjectivity; generalization:
   {markov, random_walk}→stochastic_process).

Store templates in `workspace/operator_search/templates/<NN>_<operator>.md`.

### Stage 1 — Enumerate applications (free, deterministic; no LLM)

- **Unary (ops 1–8):** the application set is every (operator, prime). ≈ 8 × ~1,170 ≈ 9,400 rows.
  Emit as a worklist `workspace/operator_search/worklist_<operator>.jsonl`.
- **N-ary (ops 9–12):** DO NOT brute-force the pair space (1,170² ≈ 1.37M). Pre-filter to pairs
  that are **DAG-adjacent**, **co-occur in a shared archetype's prime list**, or sit within an
  **embedding radius** τ. This cuts the space to low-thousands. Record the filter used.
- **Catalog-internal (ops 13–14):** no per-prime enumeration; these consume the whole
  embedding/DAG at once and emit candidate clusters/cells directly.

### Stage 2 — The cheap crank (cheapest capable model, heavily batched)

One terse generation per application. Fixed output contract:

```
CANDIDATE: <one-sentence structural description, domain-stripped>
NEAREST:   <slug of the closest existing prime you can name, or NONE>
VERDICT:   NEW | COLLAPSE
REASON:    <≤12 words>
```

- Batch many applications per call (dozens+). Keep the prompt template constant across a batch to
  maximize cache hits.
- Instruct: output `COLLAPSE` if the result is the input prime, an obvious existing prime, or not
  a genuine prime. Bias toward COLLAPSE — Stage 4 is expensive, false NEWs are the costly error.
- Persist **everything**, including collapses (they are §7 signal).

### Stage 3 — Dedup + alias screen (embeddings only, near-free)

1. Embed every `CANDIDATE` line with the same structural-signature embedder used for the corpus.
2. **Alias screen:** drop any candidate within alias distance of an existing prime (reuse the
   existing similarity machinery; the `similarity_to_nearest_existing_prime` convention already
   encodes the threshold).
3. **Cluster survivors:** near-duplicate candidates (often the *same* new prime reached by several
   operators — strong signal) collapse to one representative. Record how many operators
   independently proposed it (convergence count → priority in Stage 4).

### Stage 4 — Frontier adjudication (frontier model, survivors only)

For each survivor, one careful pass:
1. **Prime-bar test** — does it clear the prime definition (domain-general, structurally distinct,
   not an alias, not a mere domain instance)? Use the existence-check method: search corpus + pool
   by name and broad grep, not exact-slug guesses. **AND (v4.2, hard-won in the op-01 sweeps): a
   deterministic slug/alias-map lookup on every proposed slug BEFORE any frontier review** —
   semantic search verifies concept-absence but repeatedly misses name-presence (5 already-present
   primes were mis-ACCEPTed by pre-adjudicators across the op-01 sweeps; a one-line lookup catches
   them all, and each catch doubles as a balanced-granularity confirmation).
2. If it passes, **draft to standard** — mirror `random_walk.md` / `non_locality.md`: full
   frontmatter (real `one_liner`, honest SI + structural_framed proposer estimates,
   `similarity_to_nearest_existing_prime`), the fixed section set, and `review_flags` marking it
   operator-derived and pending triangulation.
3. Write to `prime_abstractions/v2_density_pilot/<slug>.md`. Do **not** draw DAG edges in the
   file; record proposed parent/child/sibling in the manifest (owner draws edges at incorporation
   — same discipline as the Phase-C emergent pass).

### Stage 5 — Owner curation (you)

Per the established review style: "review" = provisional hold, not reject; new primes get screened
against the prime definition and get a v1 draft; watch for missing-intermediate primes; multiple
parents OK, cycles not. The pipeline hands you a short, pre-justified, convergence-ranked list.

---

## 5. Sequencing (expected value per token)

Run **one operator at a time to saturation**, in this order:

1. **Dualization (op 1)** — cheapest, self-validating, immediate gaps; you already have five
   confirmed reactive finds to seed the few-shot. Best pilot.
2. **Cluster-without-parent + Generalization (ops 13, 5)** — the framed→structural **lift**;
   highest strategic value (see companion §5); mostly embedding work you can already do.
3. **Self-application (op 2)** — high value; needs frontier judgment for fixed-point detection, so
   costlier per candidate.
4. **Temporalization / Spatialization / Modalization / Threshold (ops 3, 4, 6, 8)** — cheap,
   steady moderate yield; the genuinely unturned ground; good background batches.
5. **Composition / Tension / Analogy / Interpolation / Lattice (ops 9–12, 14)** — highest setup
   and combinatorial cost; run last, on well-pre-filtered pair sets.

### Perspective inversion (op 7)
Slot alongside dualization — cheap and often paired-prime-yielding — but expect high collapse onto
existing relational primes.

---

## 6. Saturation & stopping (what makes "exhaustive" finite)

Each operator has its own accumulation curve. For each, track **accepted-new-primes per 100
applications** (Stage-5 acceptances, not Stage-2 NEWs).

- **Stop rule:** retire an operator when its trailing rate drops below **~2% accepted-new per 100
  applications** over two consecutive batches. Record the final curve.
- **Chao1 check:** periodically run Chao1 on the accepted finds using singletons/doubletons
  (primes proposed by exactly one / exactly two operators) to estimate the unseen remainder under
  the current move-set. This is the completeness number for a methods write-up.
- **Report per operator:** applications run, NEW rate (Stage 2), survivor rate (Stage 3),
  acceptance rate (Stage 5), and the saturation point. This table *is* the completeness claim.

---

## 7. Collapses are retained output (do not discard)

Persist every collapse with its operator, input, and reason. They serve three downstream uses:

1. **Corpus audit** — self-application fixed points flag maximally-general "top" primes;
   dualization collapses onto existing primes confirm balanced granularity; alias collisions
   occasionally reveal a merge you missed.
2. **Analogical-reasoning negatives** — alias-rejections and near-miss collapses are
   structurally-tempting-but-wrong candidates: the hard negatives for the synthetic-data /
   analogy-training thesis (arXiv 2602.01992). The discovery crank *is* the negative-example
   generator; store collapses in a form ready for that use
   (`workspace/operator_search/negatives/<operator>.jsonl`).
3. **Operator calibration** — a spike in false-NEW collapses at Stage 4 means a Stage-2 prompt is
   too permissive; tune the template.

---

## 8. Token budget guardrails

- **Cheap model for Stage 2, frontier only for Stage 0 and Stage 4.** Stage 3 uses no generation.
- **Cache-friendly batching:** constant template per batch; vary only the prime payload.
- **Pilot before committing:** 50-prime dry run per new operator to measure NEW-rate and
  cost-per-accepted-prime before authorizing the full ~1,170 sweep.
- **One operator in flight at a time** — bounds spend, and keeps the saturation curve per operator
  clean.
- **Stop early on saturation** (§6) rather than completing a sweep for its own sake.

---

## 9. Artifacts & layout

```
workspace/operator_search/
  templates/<NN>_<operator>.md          Stage-0 prompt + collapse test + few-shot
  worklist_<operator>.jsonl             Stage-1 enumeration
  crank/<operator>.jsonl                Stage-2 raw output (incl. collapses)
  survivors/<operator>.jsonl            Stage-3 post-dedup survivors (+ convergence count)
  negatives/<operator>.jsonl            retained collapses for training-negative use (§7)
  manifest_<operator>.yaml              Stage-4 drafts: slug, one_liner, nearest+similarity,
                                        proposed parents/children/siblings, flags
  SATURATION.md                         the per-operator curve table (§6) — the completeness claim
```
New accepted drafts land in `prime_abstractions/v2_density_pilot/<slug>.md` to the existing
standard; DAG edges are drawn by the owner at incorporation, never in the draft.

---

## 10. First action

Build `templates/01_dualization.md` (all three sub-flavors), enumerate the unary worklist for
dualization, and run the 50-prime pilot. Seed the few-shot with the confirmed reactive finds
(injectivity→surjectivity, intersection→union, lazy→eager, action_bias→omission_bias,
evolutionary_trap→maladaptation). Calibrate the collapse test against them (all five should read
as NEW at Stage 2 and survive to acceptance), then measure cost-per-accepted-prime before
authorizing the full dualization sweep. Update the Status line above with the pilot result.
