@event4u/agent-config 14.23.0 → 15.0.0

package/dist/agent-src/guidelines/agent-infra/false-green.md

@@ -0,0 +1,233 @@
+# False Green — the ways a passing result can be wrong here
+
+> Eleven failure modes, each with the detection command that distinguishes "found nothing" from "looked at nothing". Every one is drawn from this repository's own history, not from a generic checklist.
+
+_Origin: `road-to-skill-ecosystem-gate-integrity` Phase 3. The recurring shape is not that a gate reports a wrong finding — it is that a gate reports **no** finding for a reason unrelated to the property it guards, and no output distinguishes the two cases._
+
+## The catalogue
+
+### 1. Dead scan root
+
+The gate walks a directory that moved or was deleted. Zero units, zero findings,
+exit 0, green checkmark. Fourteen gates in this tree were in this state
+simultaneously after a container move; their own output said `0 file(s) scanned`
+and nothing asserted on the number.
+
+```bash
+./scripts-run src/scripts/<gate> | grep -E '^scanned: '   # 0, or absent entirely
+./scripts-run src/scripts/sweep_dead_scan_roots
+```
+
+**Structural fix:** `assertScanned` from `_lib/scan_scope.ts`. A gate that read
+nothing has not passed.
+
+### 2. Planned-but-never-judged targets
+
+The root is alive and the corpus is real, but the loop `continue`s past most of
+it on unwritten conditions. The published count says "enumerated", the reader
+hears "checked". `lint_framework_leakage` published 438 while judging 368.
+
+```bash
+./scripts-run src/scripts/<gate> | grep 'ledger:'   # scanned=N planned=M — compare N and M
+```
+
+**Structural fix:** `_lib/gate_ledger.ts`. Every planned target reaches exactly
+one terminal outcome, and the skip codes are counted per reason.
+
+### 3. Allowlist growth
+
+The gate is honest, the corpus is real, and the finding was suppressed. Count-
+based ratchets cannot see swap-one-out-add-one-in: remove a real entry, add a
+fresh suppression, the number is identical and the estate moved backwards.
+
+```bash
+./scripts-run src/scripts/check_suppression_hygiene     # entry SETS vs the base ref
+git diff origin/main -- 'src/scripts/*allowlist*.json' 'src/config/*baselines*.json'
+```
+
+**Structural fix:** `_lib/ratchet_base_ref.ts` — compare entry sets against
+`git show <baseRef>:<path>`, the one reading of the baseline the change under
+review cannot rewrite.
+
+### 4. Ratchet-entry deletion
+
+Subtler than growth: deleting a baseline entry whose `count` is 0 is **weaker**
+than leaving it, because the absence of an entry means "unbaselined" and an
+unbaselined gate's `ok` flips to `actual === 0` with no recorded intent. Harden
+first, then delete, and pin the absence.
+
+```bash
+git diff origin/main -- src/config/gate-violation-baselines.json | grep '^-'
+```
+
+### 5. Threshold re-anchoring
+
+The gate still runs, the corpus is real, and the bar moved. A lowered floor and
+a genuine improvement look identical in the exit code.
+
+```bash
+git diff origin/main -- src/config/gate-coverage.yml | grep -E '^[-+].*min_scanned'
+git diff origin/main -- 'src/config/*budget*.json'
+```
+
+**Discriminator:** a legitimate ratchet lowers *severity* while keeping *reach*;
+threshold-lowering reduces reach. Ask which one the diff does.
+
+### 6. Suppression sweep
+
+Not one entry — twenty. Allowlist growth past ~20 entries in a session is the
+signal that the linter (or the content) is wrong, not that the list is short by
+twenty. The tool-call guard blocks past that count; the honest response is to
+fix the gate's shape.
+
+```bash
+./scripts-run src/scripts/check_suppression_hygiene | grep 'entry(ies)'
+```
+
+### 7. Crashed gate read as passing gate
+
+A gate that throws is not a gate that passed, but an aggregator that only
+inspects exit codes cannot tell an exception from a clean run when the harness
+swallows it. Three of this repository's recorded traps are estate invalidation
+misreported as a per-gate red, or the reverse.
+
+```bash
+./scripts-run src/scripts/<gate>; echo "EXIT=$?"     # capture BEFORE any $( )
+```
+
+**Structural fix:** capture `EXIT=$?` on the line immediately after the command,
+never after a command substitution; and fail closed when a registered gate
+reports a null or missing verdict.
+
+### 8. A derived page reporting an unmeasured dimension
+
+The generator has no data for a category and renders a `0`, or worse a computed
+share, which reads as a measurement. The always-budget report printed `60.1%`
+for a dimension it counted **zero** artefacts in.
+
+```bash
+./scripts-run src/scripts/check_derived_page_truthfulness   # where present
+grep -rn '0%\|0 of 0' docs/*.md
+```
+
+**Structural fix:** an unmeasured category renders as absent or explicitly
+"not measured" — never as a zero and never as a share.
+
+### 9. Equality without validity
+
+Two things are compared and found equal — because neither exists. `diff a b`
+over two absent files returns equal; two empty lists both serialize to `[]`; an
+empty rendered template equals an absent target file. The gate reports
+"in sync" having compared nothing.
+
+```bash
+./scripts-run src/scripts/<gate>            # then delete ONE side and re-run
+```
+
+**Structural fix:** assert both sides exist and are well-formed BEFORE
+comparing. Two absences are the absence of a comparison, not the presence of a
+match. The estate-wide audit is below.
+
+### 10. Hook-bypass override
+
+The gate never ran because the hook that runs it was disabled for that
+invocation. `git commit --no-verify` (and its short `-n` form) skips every
+pre-commit hook; `core.hooksPath` repointed at an empty directory skips them
+permanently and silently. Both produce a commit that looks exactly like a
+commit whose hooks passed. The same shape reaches the runtime hook layer: a
+concern bound in the manifest is still inert on a host that does not honour a
+deny, so "the guard is registered" is not "the guard fired".
+
+<!-- example-fence-allow: git-no-verify -- the fence teaches how to DETECT the core.hooksPath bypass; the forbidden form has to appear for the diagnostic to be readable, and every line here is a read-only query -->
+```bash
+git config --get core.hooksPath                       # empty = repo default, good
+./scripts-run src/scripts/hooks/block_no_verify --help # the tool-call guard
+agent-config hooks:status                             # per-host bindings, not the manifest
+```
+
+**Structural fix:** the bypass is blocked at tool-call time by
+`block-no-verify` on the one host that honours a deny, and the authoritative
+gate is remote CI, which no local override can skip. Never read a local green
+as evidence when the hook path was overridden — re-run in CI, or run the gate
+directly rather than through the hook.
+
+### 11. Cached-green reuse
+
+The green belongs to a different input than the one being judged. Three real
+shapes here. A gate that reads `dist/agent-src/` passes against a **stale
+projection** while the `src/` change it was meant to judge is not in the tree it
+scanned — the recorded trap is a worktree whose stale `dist` faked generator
+drift, and its mirror, a golden capture reading `dist` where the assertion was
+about `src`. A count ratchet sits inside its limit for so long that "within
+budget" stops meaning anything, which is why a baseline carries an expiry at
+all. And the conversational form: trusting a verification run earlier in the
+same session, after the tree has moved underneath it.
+
+```bash
+bash src/scripts/condense.sh --changed        # dist != rewrite(src) => the scan root is stale
+./scripts-run src/scripts/check_condensation --summary   # byte-exactness dist vs rewrite(src)
+```
+
+**Structural fix:** regenerate before judging — this repository's `sync` task
+then its `generate-tools` task, in that order — and treat a baseline unchanged past
+`STALE_AFTER_DAYS` (56, `_lib/gate_baseline.ts:39`) as suppression rather than
+as headroom. A completion claim rests on a run made **after** the last edit, not
+on the freshest run you happen to remember.
+
+## The audited sync/parity gates
+
+Comparison-shaped gates carry entry #9's failure mode by default: `diff a b`
+where neither side exists returns **equal**. Audited 2026-08-05 across
+`src/scripts/` — **27 comparison gates, 19 guarded, 8 vulnerable, 0 undecided.**
+
+A gate is GUARDED when it asserts both sides exist and are well-formed *before*
+comparing — in this tree, almost always via `assertScanned` /
+`assertWatchlistResolves` from `_lib/scan_scope.ts`.
+
+### Guarded (19)
+
+`check_release_surface_equality` · `check_trunk_drift` · `lint_glama_drift` ·
+`check_ci_strict_superset` · `check_condensation` · `check_artefact_checksums` ·
+`check_bridge_derivation` · `check_discovery_determinism` ·
+`check_cli_registry_budget_sync` · `check_template_pin_drift` ·
+`check_gitignore_freshness` · `check_token_optimizer_freshness` ·
+`lint_eval_freshness` · `lint_behavioural_eval_freshness` ·
+`check_release_trunk_sync` · `sync_gitattributes` · `sync_gitignore` ·
+`iron_law_sha` · `check_test_coverage_diff`
+
+Two carry caveats worth knowing: `check_template_pin_drift` has an
+`--allow-empty` opt-in that is a deliberate empty-side pass, and
+`check_test_coverage_diff` is guarded but warn-only, so its guard is currently
+inert.
+
+### Vulnerable (8) — shrink-only from here
+
+| Gate | The both-absent / both-empty path |
+|---|---|
+| ~~`verify_physical_move`~~ | **FIXED in this change.** `_diff_manifest(null, null)` returned `[]`, and an empty issue list means clean. |
+| `check_ci_local_parity` | a missing workflow dir reads as `''` and a missing taskfile is skipped; two empty corpora ⇒ no delta ⇒ exit 0 |
+| `mcp_parity_smoke` | two empty lists both serialize to `[]`; prints "0 entries match" and returns 0 |
+| `probe_projection_fidelity` | a fixture that loses its `entries:` key yields 0 checks and `fail=0` |
+| `sync_agent_settings` | empty template + absent target ⇒ `'' === ''` ⇒ "already in sync" under `--check` |
+| `sync_github_metadata` | two empty topic lists ⇒ no drift ⇒ exit 0 **even under `--strict`** |
+| `check_kernel_prefix_stability` | deleting the committed snapshot returns `'warmup'` ⇒ exit 0 |
+| `bench_drift_check` | fewer than 2 reports ⇒ "no drift gate yet" ⇒ exit 0 |
+
+The seven open rows are recorded rather than swept: fixing release, sync, and
+bench gates in one change would be a large diff across surfaces this change does
+not otherwise touch, which is the unreviewable-batch failure the authoring
+guideline warns about. The fixed row shows the pattern — assert both sides
+exist, and treat two absences as the absence of a comparison.
+
+## The ease tripwire
+
+A verification that was **far easier than expected** is a signal to check the
+path, not a signal of success. Every entry above felt like a pass at the moment
+it happened. When a gate you expected to fight goes green on the first run, run
+one of the detection commands before believing it.
+
+## See also
+
+- [`gate-authoring.md`](gate-authoring.md) — the authoring path that prevents these at the source.
+- `docs/contracts/ci-green-floor.md` § CI delta — what a local pass does and does not cover.
+- `src/scripts/_lib/gate_ledger.ts`, `_lib/scan_scope.ts`, `_lib/ratchet_base_ref.ts` — the three structural fixes above.

package/dist/agent-src/guidelines/agent-infra/first-principles.md

@@ -0,0 +1,192 @@
+# First-Principles Thinking
+
+Reference guideline for Wing-1 deep-thinking work — strip away
+assumptions and conventions to reach fundamental truths, then rebuild
+understanding from the ground up. Distinct from `inversion-thinking`
+(which negates the goal) — first principles **dissolve** the goal into
+verified primitives and reconstruct it without inherited convention.
+Adopted under the **Reference-Guideline Sunset Policy** and
+cross-referenced from:
+
+- [`deep-reading-analyst`](../../skills/deep-reading-analyst/SKILL.md)
+  — L3 Deep analysis depth.
+- [`mental-models`](mental-models.md) — Munger's lattice; first
+  principles is the foundational physics-style lens.
+- [`improve-before-implement`](../../rules/improve-before-implement.md)
+  — challenge the framing of a request before coding it.
+- [`inversion-thinking`](inversion-thinking.md) — pair: first
+  principles rebuilds; inversion stress-tests the rebuild.
+
+> **Core principle:** "What is definitely, provably true?" — strip
+> the inherited and rebuild from primitives.
+
+## Three-Step Process
+
+### Step 1: Identify assumptions
+
+**Ask:** *"What do we assume to be true about this?"*
+
+List all implicit and explicit assumptions in the content:
+
+- Unstated premises.
+- Inherited wisdom (*"everyone knows…"*).
+- Industry conventions.
+- Historical precedents treated as universal laws.
+
+**Example from business:**
+
+- Assumption: *"We need a physical store to sell products."*
+- Question: is this fundamentally true or historically convenient?
+
+### Step 2: Break down to fundamentals
+
+**Ask:** *"What is definitely, provably true?"*
+
+Reduce to indisputable facts:
+
+- Physical laws (if applicable).
+- Mathematical truths.
+- Core human needs / behaviors.
+- Cause-effect relationships you can verify.
+
+**Sorting Framework:**
+
+```
+Claim → Ask: "How do I know this is true?"
+    ↓
+├─ "It just is"                       → Probably an assumption, dig deeper
+├─ "That's how it's always done"      → Convention, not fundamental
+├─ "X happens, then Y happens"        → Potential fundamental (verify causation)
+└─ "Mathematically/physically must be true" → Fundamental
+```
+
+### Step 3: Rebuild from scratch
+
+**Ask:** *"Starting from fundamentals only, what logically follows?"*
+
+Reconstruct without importing old assumptions:
+
+1. Begin with verified fundamentals.
+2. Each step must logically follow from previous.
+3. Note where you make new assumptions (be explicit).
+4. Compare new construction to original concept.
+
+## Application Template
+
+```markdown
+## Original Concept / Argument
+[What the author claims]
+
+## Hidden Assumptions
+- Assumption 1: [Something taken as given]
+- Assumption 2: [...]
+
+## Verified Fundamentals
+- Fundamental 1: [Provably true core fact]
+- Fundamental 2: [...]
+
+## Rebuilt Understanding
+Starting from fundamentals only:
+Step 1: [First logical derivation]
+Step 2: [Second logical derivation]
+...
+Conclusion: [What actually follows]
+
+## Comparison
+Original vs. rebuilt:
+- What survived: [Fundamentally sound ideas]
+- What doesn't hold: [Based on questionable assumptions]
+- New insights: [What rebuilding revealed]
+```
+
+
+## Common First Principles by Domain
+
+### Business / economics
+
+- People act in self-interest (with caveats).
+- Supply and demand affect price.
+- Value = willingness to pay.
+- Scarcity creates value.
+
+### Psychology / human behavior
+
+- Humans seek pleasure, avoid pain.
+- Social status matters to humans.
+- Cognitive biases exist (not "people are rational").
+- Habits form through repetition.
+
+### Technology
+
+- Information can be copied at near-zero cost.
+- Network effects: value ∝ n² (Metcalfe's law).
+- Moore's law (transistor density doubles ~every 2 years).
+- Computation has energy cost.
+
+### Physics / reality
+
+- Energy is conserved.
+- Entropy increases.
+- Speed of light is constant.
+- Cause precedes effect.
+
+## Red Flags: Pseudo-First-Principles
+
+Watch for claims disguised as fundamentals:
+
+- *"People always prefer X"* (overgeneralization).
+- *"This is just human nature"* (often cultural).
+- *"Economics proves…"* (many schools of economics).
+- *"Science says…"* (which study? replicated?).
+
+**Test:** can you point to specific evidence / mechanism, or is it
+folk wisdom?
+
+## Powerful Questions
+
+- *"Why is this true?"* (repeat 5 times — "5 Whys").
+- *"What must be true for this to work?"*
+- *"If I couldn't do it this way, what's another path?"*
+- *"What would an alien with no context think?"*
+- *"What if the opposite were true?"*
+
+## Worked Example — *"Need for College Education"*
+
+**Assumptions:**
+
+- Need degree to get good job.
+- Learning requires formal institution.
+- 18–22 is the right age.
+- Four years is optimal duration.
+
+**Fundamentals:**
+
+- Employers want skilled workers.
+- Skills can be demonstrated.
+- Learning requires time + practice.
+- Knowledge can be transmitted.
+
+**Rebuilt:**
+
+- → Employers want proof of skill.
+- → Proof can be: degree OR portfolio OR test OR track record.
+- → Therefore, degree is one option, not necessity.
+- → Insight: focus on skill + proof, not credential alone.
+
+## Practical Use in Reading
+
+When analyzing content:
+
+1. **Identify claims** that seem absolute.
+2. **Challenge foundations:** *"Does this HAVE to be true?"*
+3. **Verify causation:** *"Does A truly cause B, or just correlate?"*
+4. **Rebuild the argument** from indisputable facts only.
+5. **Compare** what survives vs. what was assumption.
+
+This exposes weak arguments and strengthens valid ones.
+
+---
+
+## ADOPT citation
+
+Adapted from an external reference.

package/dist/agent-src/guidelines/agent-infra/framework-neutrality-patterns.md

@@ -0,0 +1,66 @@
+# Framework Neutrality — Patterns
+
+> Forbidden-pattern table, cross-stack documentation allowance, and carve-out pointer shape for the `framework-neutrality-in-generic-skills` rule
+
+_Origin: migrated from `src/rules/framework-neutrality-in-generic-skills.md` per the P4 pattern of `road-to-kernel-and-router.md`. The Iron Law, scope, and exemption list stay in the rule; this file carries the pattern reference._
+
+## Forbidden patterns in generic artifacts
+
+| Pattern | Why it leaks | Fix |
+|---|---|---|
+| `FormRequest` as a mandate | Laravel-only validation class | Say "request-validation primitive (FormRequest in Laravel, zod in Next.js, pydantic in FastAPI)" or move to `laravel-validation` carve-out |
+| `php artisan …` as a canonical command | Laravel CLI | Generalize to "the framework's CLI" or move to `artisan-commands` carve-out |
+| `PHPStan` as the only example | PHP-only static analyser | List peers (`mypy` for Python, `tsc` for TypeScript) or move to `quality-tools` carve-out |
+| `composer.json` mentioned alone | PHP package manifest | Add `package.json` / `pyproject.toml` peers, or move to a PHP-scoped carve-out |
+| `Eloquent` / `Model::…` | Laravel ORM | Generalize to "the project's ORM/data layer" or move to `eloquent` carve-out |
+| `Pest` as the only test runner | PHP/Laravel test framework | List peers (`pytest`, `vitest`, `jest`) or move to `pest-testing` carve-out |
+| `Blade` / `Livewire` / `Flux` as default UI | Laravel view stack | Generalize to "the project's UI layer" or move to `blade-ui` / `livewire` / `flux` carve-outs |
+| `vendor/bin/<tool>` as a canonical path | PHP/Composer-specific binary path | Say "the project's quality CLI" or carve-out it |
+| `Rector` as the only refactor tool | PHP-only refactorer | List peers (`ts-morph`, `libcst`) or carve-out it |
+| "every controller" / "all controllers" | Assumes MVC PHP framework | Generalize to "every request handler" / "every endpoint" |
+
+## Allowed: cross-stack documentation
+
+Multi-stack tables or detection maps with **at least two ecosystems
+side-by-side** are documentation, not leakage. The linter's
+auto-detect heuristic skips a hit when its ±2-line window contains
+patterns from a different ecosystem family (`php_family` vs
+`js_family` vs `python_family`).
+
+Example (allowed):
+
+```
+- PHP/Composer project → `composer.json` present
+- Node project        → `package.json` present
+- Python project      → `pyproject.toml` present
+```
+
+## Allowed: carve-out pointers
+
+A generic artifact may end a section with a one-line handoff to its
+framework-specific peers. Canonical shape:
+
+```
+→ Laravel-specific: see [laravel-validation](../../skills/laravel-validation/SKILL.md)
+→ Next.js-specific: see [nextjs-patterns](../../skills/nextjs-patterns/SKILL.md)
+```
+
+The pointer is a link, not a procedure — the generic artifact never
+inlines stack-specific code.
+
+## Enforcement
+
+`scripts/lint_framework_leakage.ts` runs in the package CI pipeline.
+Exit codes:
+
+- `0` — no hits, or every hit is auto-detected as cross-stack, or
+  every hit is allowlisted in
+  `scripts/lint_framework_leakage_allowlist.json` with a `reason`.
+- `1` — at least one hit in a generic artifact (non-carve-out) that
+  is neither cross-stack nor allowlisted.
+
+## See also
+
+- `framework-neutrality-in-generic-skills` (rule) — Iron Law, scope, exemption list.
+- `roadmap-ci-steps-policy` — sibling Tier-2a rule that drove this pattern.
+- `skill-quality` — every skill must remain executable; carve-outs must still pass skill-quality.

package/dist/agent-src/guidelines/agent-infra/frontier-reasoning-operating-profile.md

@@ -0,0 +1,169 @@
+# Frontier-Grade Reasoning — Operating Profile
+
+> Source dossier for the **Reasoning Discipline Protocol (RDP)** — the durable,
+> sourced rationale behind the RDP gate context, rule, and skills. It documents what a
+> frontier reasoning model (Anthropic's Fable 5 / Mythos 5, June 2026) does that
+> weaker models skip — the **transferable operating discipline** — and the
+> boundary of what is *not* transferable.
+>
+> **User entry point:** for the one-screen "what it does / when it fires / how to
+> turn it off" contract, see
+> [`docs/contracts/reasoning-discipline-protocol.md`](../../contracts/reasoning-discipline-protocol.md).
+> This dossier holds the depth; that contract is where users start.
+>
+> Citation discipline: every catalog row names its source **and its dignity**
+> (Anthropic primary doc · third-party review · customer testimonial · our own
+> derivation). Two independent external model analyses (Claude + GPT) corroborate
+> but are never the primary evidence for a transferable-behavior line. A
+> line-by-line audit (2026-06-13) corrected five rows; the load-bearing claims
+> (over-prescription degrades, reasoning-in-response → refusal) are verbatim in
+> Anthropic's prompting doc and stand.
+
+## The one boundary that frames everything
+
+```
+CAPABILITY DOES NOT TRANSFER. DISCIPLINE DOES.
+```
+
+A frontier model's edge lives in its **weights** — gains spread across the whole
+training stack, with no single copyable prompt (the explicit framing is Nathan
+Lambert / Interconnects [lam]; Anthropic's docs support only the weaker "needs
+less scaffolding" [pf]). No skill, rule, or workflow makes Sonnet/Opus/GPT
+*equal* Fable 5, and anyone promising that is selling the hallucinated analysis
+this suite refuses to produce.
+
+What *does* transfer is the **operating discipline**: the steps a frontier model
+takes on its own that weaker models skip unless forced. On under-specified and
+long-horizon tasks, that discipline gap is the largest part of the *visible*
+quality difference. RDP transplants the discipline; it never claims the
+capability.
+
+> **Background (dates, precise):** Anthropic's own banner dates the **access
+> suspension of Fable 5 / Mythos 5 to 2026-06-12** [an]; the related US
+> export-control directive / Reuters report is **2026-06-13** [re]. Either way
+> the model is currently inaccessible, so we cannot A/B against it — our own
+> falsifiable eval is the only ground truth, which makes the discipline-transplant
+> approach *more* relevant, not less.
+
+## Sources (with dignity)
+
+- **[an]** Anthropic — *Claude Fable 5 and Mythos 5* announcement. Primary, but
+  several quotes on the page are **customer testimonials** (labeled per-row), not
+  Anthropic capability statements.
+- **[pf]** Anthropic docs — *Prompting Claude Fable 5*. Primary; the transferable
+  prompting playbook. Load-bearing claims live here.
+- **[in]** Anthropic docs — *Introducing Fable 5 / Mythos 5*. Primary; adaptive
+  thinking + effort parameter + memory tool + refusals.
+- **[ve]** Vellum — benchmark breakdown. **Third-party**; benchmark numbers are
+  not verifiable in Anthropic prose and must be labeled third-party or pulled to
+  the system card.
+- **[cr]** CodeRabbit model review. **Third-party**; source of the
+  "explore-environment-first" observation (not Anthropic-documented).
+- **[lam]** Nathan Lambert / Interconnects. **Third-party analysis**; "whole
+  training stack, no copyable prompt".
+- **[re]** Reuters — export-control report (2026-06-13).
+- Two external model analyses (Claude + GPT), provenance untracked in
+  `agents/.harvest-local/` — **corroboration only**, never primary.
+
+## Transferable-behavior catalog
+
+Each row: behavior → **source + dignity** → transplant mechanism → carrier.
+
+| Behavior | Source (dignity) | Transplant | Carrier |
+|---|---|---|---|
+| Audit progress against real tool results | **[pf] ✓ primary** | every claim cites a tool result | shipped: `verify-before-complete` |
+| Act when you have enough; no overplanning; outcome-first | **[pf] ✓ primary** | shipped | `direct-answers`, `autonomous-execution` |
+| Pause only when genuinely needed | **[pf] ✓ primary** | shipped | `no-cheap-questions` |
+| No over-refactor / minimal diff (at higher effort) | **[pf] ✓ primary** | shipped | `minimal-safe-diff` |
+| Parallel async subagents, dispatched readily | **[pf] ✓ primary** | default async dispatch | extend `subagent-orchestration` |
+| Fresh-context verifier beats self-critique (for **long-running** tasks) | **[pf] ✓ primary** | verifier subagent on a **structural-complexity** gate (not blanket) | extend `adversarial-review` |
+| Persistent **cross-run** notes (file memory = 3× vs Opus 4.8 on Slay the Spire) | **[an] ✓ primary (direct)** | lessons across runs, one per file | extend memory / `memory-consolidation` |
+| Infer the underlying goal (standard host only) | **[an] testimonial (Lovable); direction note** | infer goal, give **one** recommendation — NO "2–3 framings"; standard host only (a strong-reasoning host self-infers) | extend `improve-before-implement` |
+| Multi-hypothesis / "killing incorrect beliefs" | **[an] testimonial (Sean Ward); "multi-hypothesis" is our framing** | hypotheses + killed-beliefs in the notes file | `notes-first-reasoning` |
+| Adaptive effort (depth scales with hardness) | **[in],[pf] = API knob, not a scaffold** | strong-reasoning host: set `effort: high`; standard host w/o the knob: scaffold the effort/stop discipline | extend `autonomous-execution` (standard-host-only) |
+| Explore the environment first, then build | **[cr] third-party (NOT Anthropic-documented)** | enumerate constraints/tools/info-gaps, close by query/test before designing | extend `think-before-action` |
+| Risk-first decomposition (hardest/load-bearing unknown first) | **OUR DERIVATION — general engineering discipline, NOT Fable-documented** ([pf]'s "top of difficulty range" means **task selection**, not intra-task order) | resolve load-bearing uncertainties before dependent work | new skill `complexity-first-planning` |
+
+Adopted from GPT review (frontier-implicit behaviors; our adoption, corroboration
+only — all cost-gateable notes components):
+
+| Behavior | Source | Transplant | Carrier |
+|---|---|---|---|
+| Prediction tracking (calibration) | GPT review | prediction + confidence + result + lesson in notes | `notes-first` component `prediction_tracking` |
+| Uncertainty budget | GPT review | per-dimension uncertainty score → feeds adaptive effort | `notes-first` component `uncertainty_budget` |
+| Decision ledger | GPT review | decision + alternatives + reason + revisit-if in notes; **escalates to `decision-record`/ADR** when cross-task or structural | `notes-first` component `decision_ledger` |
+
+The ordered chain the orchestrator enforces:
+`ground → intent → notes → gather → audit → verify`.
+
+## Deferred to the Phase-8 audit (likely already covered)
+
+Two transferable [pf] behaviors are **not** given new artifacts up front — the
+Phase-8 de-prescriptivize audit checks existing coverage first and adds only
+verified gaps (HIGH priority):
+
+- **Re-ground the final summary** — write the closing summary for a reader who
+  saw none of the working thread; outcome first; drop working shorthand. Likely
+  covered by `language-and-tone` + `direct-answers`.
+- **Report findings and stop** — when the user is thinking out loud, don't apply
+  a fix. Likely covered by `scope-control`.
+
+## What does NOT transfer (and must not be faked)
+
+- **Raw capability** — vision SOTA, document/chart reasoning, codebase-scale
+  migrations. Benchmark deltas (e.g. SWE-Bench Pro 80.3 vs 69.2) are **[ve]
+  third-party**, not verifiable in Anthropic prose — label third-party or pull to
+  the system card; note "SWE-Bench Pro" is not named in [an] (which cites
+  FrontierCode/Cognition + Hebbia-Finance). These are weights, not prompts.
+- **"Show your work" in the response.** [pf] warns that reasoning-in-response can
+  trigger a `reasoning_extraction` refusal, and that over-prescriptive skills
+  *degrade* strong models. **Both verbatim in [pf] — the gating foundation.** RDP
+  keeps reasoning in notes + verifier subagents, never in the response, and
+  tier-gates prescription.
+- **Pokémon FireRed vision-only harness** — **[an] only** ([pf] does not mention
+  it).
+
+## Cost / benefit by host reasoning strength (the gating lens)
+
+RDP is **not** free — scaffolding costs tokens and, on strong-reasoning hosts,
+*degrades* output. So it engages only where it pays, via **table-free** signals.
+Per **ADR-035** the suite maintains no runtime model→band table, and `model_tier`
+is the *skill's* needed band (lite/medium/high), **not** the host's. Host strength
+is therefore **agent self-assessed**, never looked up (roadmap L10/L17):
+
+| Host / task | Self-coordination | RDP engagement | Why |
+|---|---|---|---|
+| standard host | low | **full** scaffolding | biggest discipline gap → biggest lift |
+| strong-reasoning host | high | **light / off** (use native `effort: high`) | over-scaffolding degrades + wastes tokens |
+| trivial / short task (any host) | n/a | **off** | no discipline gap to close; pure overhead |
+| verifier subagent (any host) | — | **only** on the structural-complexity gate (≥2 of: branching, ≥3 constraints, stateful, irreversibility) + token floor ≥1k | a full extra inference pass — the most expensive primitive |
+
+**One** constraint-light scaffold ships — no heavy/light content variants, since
+two variants would be a hidden model→band table. A standard host **expands it on
+request**. Two gates, both default-on: automatic (task signal + agent
+self-assessment) + the user `reasoning:` settings toggle (global + per-component
++ hard off).
+
+## Notes template grounding
+
+The session-notes template is grounded in Anthropic's **documented cross-run
+lessons memory** [pf] (one lesson per file; corrections + confirmed approaches;
+why they mattered). The in-task sections (`## In-Task Hypothesis Log`,
+`## Predictions`, `## Decisions`, `## Uncertainty`) are a clearly-marked **local
+derivation** for within-task scope — useful, but not claimed as Anthropic-
+documented, and kept on the notes side of the `reasoning_extraction` line.
+
+## Naming
+
+Neutral, no brand/capability claim. Umbrella: **Reasoning Discipline Protocol
+(RDP)**. Artifacts: `reasoning-orchestrator`, `notes-first-reasoning`,
+`complexity-first-planning`, `environment-grounding`. "Fable" / "Mythos" never
+appear in an artifact identifier.
+
+[an]: https://www.anthropic.com/news/claude-fable-5-mythos-5
+[pf]: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5
+[in]: https://platform.claude.com/docs/en/about-claude/models/introducing-claude-fable-5-and-claude-mythos-5
+[ve]: https://www.vellum.ai/blog/claude-fable-5-and-mythos-5-benchmarks-explained
+[re]: https://www.reuters.com/technology/us-blocks-foreign-access-anthropics-most-advanced-ai-models-axios-reports-2026-06-13/
+[cr]: https://www.coderabbit.ai/blog/fable-5-model-review
+[lam]: https://www.interconnects.ai/p/claude-fable-5-and-new-ai-safety