<!--
SPDX-License-Identifier: CC-BY-SA-4.0
(MPL-2.0 is automatic legal fallback until PMPL is formally recognised)
-->

# Briefing Opus (4.7 and later)

Opus is the top tier. In this estate it has two distinct roles, and a brief
should be clear about which one applies:

1. **Opus as worker** — the task itself requires Opus's capabilities (formal
   proofs, language/compiler design, cross-repo synthesis, novel architecture).
   This is "do the work yourself".
2. **Opus as supervisor** — the user wants Opus to orchestrate cheaper models
   (Haiku, Sonnet) on mechanical sub-parts and only use its own capability
   for design, verification, and final synthesis. This is "run the
   subcontractors".

Both modes share the same brief skeleton, but the expectations differ. Always
state which mode you are invoking.

## Fits (Opus as worker)

- Formal proofs: Idris2 / Agda / Lean / Coq-Rocq / TLA+ / F\* / L4 / Iz / ECHIDNA
- Compiler / interpreter / type-system design and implementation
- Language dialect design (e.g. My-Lang Solo ⊂ Duet ⊂ Ensemble, Me runtime
  projection)
- Cross-repo architectural refactors that touch invariants in multiple repos
- Paper review, publication pre-flight calls, dual-use threat modelling
  (claim-grounders: invariant-path, PLASMA, Hypatia, ECHIDNA, Bullshit Field)
- Grammar audits with semantic depth (concurrency primitives, AI semantics,
  dependent types, effect systems)
- Any task requiring the estate's full priority order to resolve tradeoffs
  (dependability > security > interop > usability > performance > versatility >
  functional extension)
- Debugging where the bug crosses layers (ABI / FFI / runtime / prover)
- Novel infrastructure: innervation architecture (6a2 → coordination.k9 +
  VeriSimDB + Hypatia), new contractile semantics, new claim-grounder design

## Fits (Opus as supervisor)

- Large estate-wide audits where the *aggregation* is easy but the *sampling*
  is big — hand the sampling to Haiku, do the aggregation yourself
- Multi-repo implementation passes where per-repo work is specifiable — hand
  per-repo work to Sonnet, verify seams and cross-repo invariants yourself
- Any task list of mixed difficulty — sift into Haiku / Sonnet / Opus-only
  and iterate until only the Opus-only residue remains
- Prompt design for the subordinate tiers — the supervisor writes the
  Haiku/Sonnet brief and evaluates its output

## Does not fit

- Pure data collection with no synthesis needed (send to Haiku)
- Well-scoped single-repo implementation where the design is decided (send
  to Sonnet)
- UI / frontend prototyping (Vibe / specialist tier)
- Anything where Jonathan has already ruled "human only" — token/credential
  actions, external submissions, strategic timing calls, public-facing risk
  acceptance. Opus must recognise and surface these, not attempt them.

## Cost model

Opus is the most expensive tier. Direct work at Opus rate is justified when:

- The task requires reasoning the cheaper tiers cannot do
- The context needed cannot be reduced to a tractable Haiku/Sonnet brief
- A mistake would be expensive to undo (proofs, architecture, published
  papers, signed commits to main)

Supervision-mode Opus is usually the estate's most *cost-effective* option
for large mechanical work, because Opus absorbs only the briefs and summaries
while Haiku absorbs the bulky tool output.

## Prompt scaffold (Opus as worker)

```markdown
You are <role statement: e.g. "proving the atomicity lemma for Hypatia's Kin
gate in TLA+">.

# Context

<This section is LONGER than for Haiku/Sonnet. Opus can and should absorb
multi-paragraph context. Include:
- The invariants that must hold
- The estate's priority order (dependability > security > interop > ...)
- The architectural defaults (Idris2 ABI, Zig FFI, Chainguard, Podman,
  Containerfile, Deno first, V-lang banned, Rust/SPARK, A2ML not SCM, etc.)
- Any cross-repo dependencies Opus must respect
- Prior attempts and why they failed, if known>

# Task

<The concrete deliverable. State what "done" looks like:
- Theorem name / file path
- Tests or proofs that must pass
- Invariants that must be demonstrated>

# Hard rules

- License / SPDX per file
- Banned patterns: believe_me, assert_total, Admitted, sorry, unsafeCoerce,
  Obj.magic — zero tolerance
- Proof prefers Idris2 as backend; ECHIDNA orchestrates where dispatch is needed
- When proven Idris2 code conflicts with Ephapax linear types, Idris2 wins
- "Rust" means "Rust/SPARK"; design new Rust projects to admit SPARK modules
  via Idris2-ABI + Zig-FFI
- No JSON emit — A2ML (data) or Nickel (schemas)
- Bot-primary design docs ship as .a2ml with optional .adoc narrative
- No stubbing default; wire everything through
- Full battery before claims: tests + benches + panic-attack + proofs + axioms
  + causality + verifiable I/O
- Seam check: when two items complete together, verify the integration boundary
  end-to-end

# Report at end of session

- What was proven / built / decided
- What was NOT done and why
- Remaining holes (Admitted, postulate, placeholder) with a plan
- Handoff notes if the work is paused mid-flight
- Memory / documentation updates made
- Commits pushed (if any; default is not to commit without explicit ask)
- `SAFE TO CLOSE` on its own line at the very end if and only if this was a
  planned session close per standards/session-management-standards
```

## Prompt scaffold (Opus as supervisor)

```markdown
You are supervising a sweep of <task set> across <scope>. Your job is to:

1. Sift the task list into Haiku-eligible, Sonnet-eligible, and Opus-only.
2. Run Haiku / Sonnet on their eligible tasks, with briefs following
   standards/ai-instruction/{haiku,sonnet}.md.
3. Verify each subordinate's output before accepting it.
4. Aggregate the results and produce the Opus-only residue list for direct
   work.
5. Respect the estate cap: max 3 parallel subagents, 2 parallel Bash.
6. Respect "private repo ops are sequential only".

At the end, report:
- Tasks closed by Haiku (with verification notes)
- Tasks closed by Sonnet (with verification notes)
- Tasks that remain Opus-only and why
- Any anti-patterns you caught in subordinate output, so the briefs can be
  tightened
```

## Hard rules to include verbatim

Even when Opus has prior-conversation context, a delegation prompt or a fresh
session should restate:

1. **Priority order** — dependability > security > interop > usability
   (incl. marketability/positioning/accessibility) > performance >
   versatility > functional extension. Sort findings by this, not by severity
   alone.
2. **License baseline** — PMPL-1.0-or-later with MPL-2.0 as legal fallback;
   AGPL-3.0-or-later for IDApTIK and Airborne Submarine Squadron; preserve
   third-party licences.
3. **Architectural defaults** — Idris2 ABI, Zig FFI, ECHIDNA-orchestrated
   proofs with Idris2 backend, A2ML checkpoint files, Chainguard base images,
   Containerfile, Podman, Deno first, V-lang banned, Rust-means-Rust/SPARK.
4. **Banned patterns** — full list; no escape hatches.
5. **GitHub is single source of truth** — push ONLY to `origin`; other forges
   are mirrored downstream; exceptions are `007` (never mirrored) and
   `bitfuckit` (Bitbucket-primary). Do not push to GitLab/Bitbucket/Codeberg
   directly to "fix mirror drift".
6. **Private repo ops are sequential.** Never parallel. `007`,
   `.git-private-farm`, `hyperpolymath-sovereign-registry`, `blog-drafts` are
   always-private.
7. **Full-battery-before-claims.** A tool does not get to make claims until it
   has passed tests + benches + panic-attack + proofs + axioms + causality +
   verifiable I/O.
8. **Claim-grounders are dual-use** under Akerlof. Apply the governance
   addendum (covenant, threat model, responsible disclosure, signed releases).
9. **Session close markers.** When closing a repo per
   `standards/session-management-standards`, flip TaskCreate `activeForm` to
   `CLOSING DOWN — <repo>` and end the final message with literal
   `SAFE TO CLOSE` on its own line.

## Trust level & verification

**Default trust: self — but verify before claiming.**

Opus's own failure modes are harder to catch because its output is usually
coherent. Catches that have saved the estate:

- **Memory staleness.** A memory that names a function or flag is a claim
  about a past state. Verify the file / grep the symbol before recommending.
- **Pattern-completion into confident wrongness.** When the estate has strong
  conventions, Opus will sometimes extrapolate a convention into a domain
  where it does not apply. Check against the actual spec.
- **"Done" on build-success.** `dune build` / `cargo build` / `deno task
  build` passing is not completion. Cite a behavioural test.
- **Silent scope expansion.** If the initial brief was "add X", and you
  notice you also touched Y and Z, stop and ask whether that was wanted.

## Anti-patterns in briefing (or self-briefing) Opus

- Treating Opus as Sonnet. "Just implement this spec" is often a Sonnet
  brief; if you send it to Opus, you are paying the premium without using
  the capability. Conversely, sending a proof task to Sonnet is false economy.
- Not stating the mode (worker vs. supervisor). The brief structure differs.
- Withholding priority-order context. Opus's highest-value contribution is
  resolving tradeoffs the cheaper tiers cannot; starve it of the criteria and
  you degrade to Sonnet-quality output.
- Letting Opus supervise without giving it a concrete sift criterion for
  Haiku vs. Sonnet vs. self. The supervisor brief should reference
  `standards/ai-instruction/haiku.md` and `.../sonnet.md` so the criteria are
  consistent across sessions.

## Parallelism

Same estate cap: **3 parallel subagents, 2 parallel Bash.** Opus supervising
Haiku + Sonnet in parallel counts toward this cap. Private-repo work is
sequential only.

## License

PMPL-1.0-or-later (MPL-2.0 automatic legal fallback).
