# Codex Formal Answer

> Use when answering mathematical, conceptual, philosophical, or metaphysical questions through repository-first scientific reasoning, a clause-complete formal bridge, retained exact Lean specializations, reusable library growth, and an ordinary conversational answer; the formal work stays internal and is shown only when the user asks for it.

- Skill: `chronoaiproject/codex-formal-answer` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx get-skill add chronoaiproject/codex-formal-answer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/chronoaiproject/codex-formal-answer/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Marketing & Growth
- Author: ChronoAIProject (https://skillmd.com/u/chronoaiproject)
- Updated: 2026-11-16
- Page: https://skillmd.com/skills/chronoaiproject/codex-formal-answer

---


# Codex Formal Answer Workflow

## Install

This repository copy is the single source of truth for `skills/codex-formal-answer/`; any installed copy is a projection of it.

## Scope and authority

This file is Codex-specific packaging of repository obligations; it has no authority of its own. `docs/develop/spec/golden-ledger-repo-spec.md` is the sole normative specification; `CLAUDE.md` is the invariant frame governing how work is done; and `agents/CONTEXT.md` is the finite-context map and routing aid, not an authority above the specification. Live harness output is the decisive judge of fact about the current tree. If this file disagrees with any of them, they win and this file is the bug.

This skill produces two things. An internal assertion record for the current run always exists, including when no Lean is written. The default public product is an ordinary conversational answer rendered from that record; the user sees only that answer unless they ask for the record (see the conversation contract). The internal record carries the clause inventory, `P`/`G`/`S` bridge, premise map, evidence, outcomes, conditions, and derivation; Step 7 directs the public answer to be drafted only from that record and subjects it to a bounded worker audit. That audit reduces leakage but cannot guarantee that natural-language strength never exceeds the register.

codex-formalize owns digestion atoms and their deposit and coverage workflow. This skill owns the user's clause-complete `P`/`G`/`S` bridge, inferential completion, assertion register, renderer, and reusable formal-library growth. Do not import freezing, deposit, coverage, or truth-DAG publication machinery. Every formalizable gap must end in one of three states: an existing complete project theorem is reused, a new abstract `G` is retained as canonical project source, or the gap remains `open`. Every `S` that successfully compiles exact `P` through the current `make` door with an accepted axiom closure is retained as `tracked-S`; this preserves the exact specialization but does not promote scenario-specific code into a reusable `G`, so `tracked-S` alone never closes a missing reusable-library obligation.

## Conversation contract

This skill is one agent, not three behaviours. In every turn the user talks to an ordinary assistant, the thinking behind the reply is done as formal work inside this repository, and the reply comes back as an ordinary answer that can carry its own record on request. The three clauses below hold together in the same turn: none can be taken without the others, and none is a mode the user switches into.

1. `plain`: what the user sees is an ordinary conversational answer rendered from the internal record under Step 7. It carries no `P`/`G`/`S` labels, GIDs, module paths, build receipts, search traces, or outcome vocabulary, and nothing in its wording reveals that a formal method ran; it never says less than the register permits merely to hide the method.
2. `show-work`: the option to return the thinking is part of the same answer, not a different one. When the user asks to see the reasoning, in any wording, append the current run's internal `record` after the plain answer, verbatim from the Step 1 to Step 6 records: the clause inventory, the `P`/`G`/`S` bridge, the premise map, the search trace, every build command with its exit code, the settlement register with its validity history, and `side_effects`. Never re-narrate the record: the answer with the record attached claims exactly what the answer without it claims (`disclosure_preserves_claims`). The record shown is the current run's; do not promise later retrieval.
3. `in-repository`: the thinking that produces every answer is done inside the repository worktree, as files, not in prose. Every `formalizable` assertion is written as Lean under `D5/`, placed in the canonical mathematical subject domain selected by Step 4, and judged by `make lean` before Step 5: on the reuse route, an `S` applies the cited declaration to exact `P`; on the new-`G` route, the reusable `G` is written in its canonical project module and a separate `S` applies it to exact `P`. Prose that was never compiled yields no formal outcome, and reading a module is not the same act as compiling against it (`rendered_formal_claim_is_compiled`). Step 6 retains every successfully compiled exact specialization as `tracked-S`, as well as every successful new abstract `G` and their canonical Describe sources; a missing reusable abstraction remains `open` rather than disappearing behind the retained specialization.

The three clauses are one theorem chain in the self anchors below: the answer's formal claims come only from compiled evidence, the audited prose is the same with or without the record, and what the record option attaches is the record itself. Each user turn is one run of the state machine. Records of earlier turns in the same conversation are context for Step 1 and Step 2, never a substitute for a current build: a claim carried over from an earlier turn is re-settled from its own evidence in this run or reported as `open`.

## Read first

- `CLAUDE.md`, especially items 4, 5-double-prime, 6, 11, 15, 18, and 20-prime, plus section VI's ban on hedge-words substituting for measurement.
- `agents/CONTEXT.md` and `agents/echo-template.md`.
- `docs/develop/spec/golden-ledger-repo-spec.md`, `Meta/FILEMAP.toml`, `Meta/domains.yaml`, and `make help` when repository mutation is in scope.
- Existing Lean declarations and Describe sources reached by Step 2; read `tools/lean-inspector/Inspector.lean` only when an axiom-closure report is material.

## Method anchors

`CLAUDE.md` item 5-double-prime solely owns the meanings of the eight disciplines and marks their use as agent reasoning as analogical. The registry below supplies only grep-resolvable frozen declaration addresses; it does not restate theorem content or assert a one-to-one discipline/declaration mapping. The forward-commitment discipline has no single frozen declaration and is carried by the existing machinery named in `CLAUDE.md`. The Pareto discipline has two anchors.

- `lookup_copy_zero_loss_and_nonanticipating_failure` - `D5/S3/ConceptDynamics/DefinitionEscapeAdjudication/RetrospectiveLookupFailure.lean`
- `blind_residual_charge_decomposition` - `D5/S3/ConceptDynamics/EscapeSpectrum/BlindResidualChargeDecomposition.lean`
- `budget_envelope_infimum_and_limit` - `D5/S3/ConceptDynamics/EscapeSpectrum/BudgetEnvelopeCompletion.lean`
- `append_only_old_settlement_unchanged` - `D5/S3/ConceptDynamics/DefinitionEscapeAdjudication/TargetChangeSettlementConservation.lean`
- `pareto_weak_reflexive_transitive` - `D5/S3/ConceptDynamics/DefinitionEscapeAdjudication/ParetoWeakPreorder.lean`
- `gain_difference_self_zero_and_cocycle` - `D5/S3/ConceptDynamics/DefinitionEscapeAdjudication/GainDifferenceCocycle.lean`
- `dependency_closure_admission_antitone` - `D5/S3/ConceptDynamics/DefinitionEscapeAdjudication/DependencyClosureAdmissionAntitone.lean`
- `spectrum_commitment_local_settlement` - `D5/S3/ConceptDynamics/EscapeSpectrum/SpectrumCommitmentSettlement.lean`

## Self anchors

The register and renderer that Steps 5 and 7 describe are themselves formalized in this repository, so the skill's own logic is a set of compiled declarations that the skill can cite like any other. Steps 5 and 7 must agree with these declarations: where this prose and the compiled statement differ, the compiled statement is the model and this file is the bug.

- `settle_first_match` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`
- `failed_build_settles_open_or_not_formalized` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`
- `not_formalized_independent_of_build` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`
- `open_permits_only_unsettled` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`
- `formal_claim_requires_successful_build` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`
- `revise_preserves_history_prefix` - `D5/S3/ConceptDynamics/Answering/RegisterValidityHistory.lean`
- `revise_leaves_exactly_one_active` - `D5/S3/ConceptDynamics/Answering/RegisterValidityHistory.lean`
- `revise_preserves_other_keys` - `D5/S3/ConceptDynamics/Answering/RegisterValidityHistory.lean`
- `rendered_takeaway_within_ceiling` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`
- `rendered_formal_claim_is_compiled` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`
- `open_key_blocks_emission` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`
- `disclosure_preserves_claims` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`
- `show_work_exposes_record` - `D5/S3/ConceptDynamics/Answering/AssertionSettlementCeiling.lean`

What these theorems say: the five outcomes are assigned by exhaustive first match; a failed build settles nothing and cannot reclassify a clause; an `open` record permits only the claim that conveys nothing about `P`; every formal-grade claim the ceiling permits, and therefore every one an audited answer conveys, is backed by one successful build; revision keeps exactly one active settlement per assertion key without overwriting the history; and the show-work switch attaches the record without changing the audited claims. What they do not say: they verify no particular answer, they do not decide whether a Lean statement is the user's `P`, and they do not model the competent-reader mapping from prose to takeaways, which remains the Step 7 worker judgment. The self-reference is the ordinary internalization of this repository: a procedure that judges by compiled declarations is itself a compiled declaration one layer up, and the layer above that one is still `open`.

## State machine

Follow the steps in order. Do not pass a step until its postcondition holds.

### 0. Fix the answer commitment

Before searching, record the candidate answer propositions, what would count as answering each one, what would refute each one, and the bounded stopping and settlement criteria. Apply the forward-commitment discipline from `CLAUDE.md` item 5-double-prime; do not revise the criteria to fit evidence already seen.

Postcondition: the answer, refutation, and stop conditions are fixed before evidence collection.

### 1. Inventory raw clauses

Split the input into assertion records and give each assertion a stable key that survives later revision. Preserve every material object, relation, qualifier, alternative meaning, empirical premise, and metaphysical premise exactly once. Turn a question into candidate truth-valued answer propositions rather than grading the interrogative. Model alternative meanings with explicit indices instead of silently choosing one.

Classify each assertion from its clause shape as `formalizable`, `conditional-empirical`, `ambiguous`, or `not-formalizable`. It is formalizable exactly when a truth-valued `P` can be stated with explicit types, relations, quantifiers, and hypotheses. Fix the classification here; proof difficulty, elapsed effort, convenience, and compiler availability cannot later change it. A formal representation does not establish that its empirical, existential, metaphysical, or interpretive premises hold in reality.

Before assigning a broad conceptual assertion to `not-formalizable`, extract its maximal `formalizable-core`: every precise conditional consequence, structural relation, boundary case, and counterexample shape receives its own stable key and exact `P`. A nonformal outer interpretation may remain, but it cannot hide a formalizable subclaim from the `G`/`S` and persistence workflow. A `conditional-empirical` record with an exact proposition is part of this formalizable core; its real-world premises remain undischarged.

Postcondition: every material clause has one stable-keyed record, one fixed classification, and a candidate exact `P` or an explicit reason no exact `P` can yet be stated; every broad or ambiguous input has a recorded maximal-formalizable-core audit, with each extracted proposition routed independently.

### 2. Search and model

Execute `C`, `F`, and `M` in that order and retain queries, result counts, addresses, and reuse decisions.

1. `C`: enumerate text-bearing semantic surfaces from `Meta/FILEMAP.toml`; search at least `D5/`, `Blueprint/`, `Library/`, `Problems/`, `docs/develop/theory/`, `Evidence/`, `Chronicle/`, and `Meta/Digestion/`. Search original wording, translations, historical terms, synonyms, antonyms, and structural roles; follow relevant references and Describe dependencies.
2. `F`: trace useful concepts to exact declarations and statement shapes in `D5/`, rendered meanings in `Blueprint/`, and pinned abstractions in `.lake/packages/mathlib/Mathlib/`. Search the proposed conclusion, its negation, and counterexample shapes. Follow `CLAUDE.md` item 11's repository, mathlib, third-party, local-proof order. Stop external theorem search at an exact repository hit, but continue inferential completion unless that one declaration closes the complete proposition. Reuse and apply the strongest exact declaration that supplies the needed claim; never reprove it or add a renamed copy. A weaker exact hit does not license rebuilding what a stronger declaration already supplies.
3. `M`: construct the candidate `P`, reusable `G`, and applying `S` from discovered carriers, relations, contexts, histories, modalities, observers, and premises. Map what the declarations jointly imply and name the remaining inferential gap. A hit list or prose synthesis does not answer a complex question that still requires composition.

Do not call search complete when output was truncated, a referenced source was unopened, or either the semantic or statement-shape pass was skipped. Prose may choose vocabulary and model boundaries; only compiled Lean can establish a formal outcome.

Invoke the remaining disciplines from `CLAUDE.md` item 5-double-prime here. Bind lookup-copy, blind-residual, budget-envelope, Pareto/gain, and dependency-closure admission to `C`/`F`/`M` route evaluation, and record each application and result; Step 5 owns append-only and local settlement.

Search chooses only the implementation route: reuse one exact compiled declaration that already supplies the complete reusable `G`; otherwise compile a new load-bearing abstract `G` for canonical retention; or, for a `not-formalizable` record only, produce no Lean. There is no successful thin-only route: when no existing theorem covers the complete inference and no reusable `G` can be built, the formal result remains `open`. Failed proof, unavailable compiler, elapsed effort, and convenience do not revise Step 1; they leave the internal result unsettled.

Across all routes, record an unavailable required capability with its command and result or an explicit unavailable-state note; never silently treat it as completed work.

Postcondition: every source has a role and trust status, the inferential gap and ambiguity class are explicit, and exactly one implementation route is selected without changing formalizability.

### 3. Fix the exact statement echo

Complete `agents/echo-template.md` separately for every `formalizable` assertion: exactly one auditable bridge per `formalizable` assertion key, not one bridge per run. Do not retain competing bridges for the same assertion key.

1. `P` is the clause-complete truth-valued proposition answering the user's actual question.
2. `G` is a reusable theorem over repository-native carriers and relations. It replaces scenario names and question-specific constants with parameters and explicit hypotheses, retains the inferential content of `P`, and adds a consequence not already assumed or merely listed. Its `generalization-audit` must show that the statement is named and typed for a theorem family rather than this conversation, that each load-bearing hypothesis is used, and that a semantically distinct specialization or nontrivial countermodel can inhabit the same abstraction.
3. `S` applies `G` to exact `P` through a total explicit substitution map and discharges every formal hypothesis. Its statement is exact `P` or exact negation of `P`; it does not independently reprove the result.

If `P` is already canonical and reusable, use `G := P` and an identity substitution as `S`; there is no bridge exception. Map every clause of `P` to a parameter, premise, conclusion, or substitution. Keep context, tradition, observer, world, modality, time, and empirical or metaphysical premises explicit where relevant.

For every `not-formalizable` assertion, record the Step 1 reason no exact `P` can yet be stated and proceed directly to Step 5 without manufacturing a `P`/`G`/`S` bridge.

Postcondition: each `formalizable` assertion key has exactly one fixed `P`/`G`/`S` bridge, clause coverage, and total substitution map, with no hidden premise and no hypothesis that assumes the conclusion; each `not-formalizable` key has its recorded reason and no bridge.

### 4. Implement the inferential completion

Before writing either `G` or `S`, complete a `placement-audit`: choose its `canonical-domain` from the theorem's `mathematical-subject`, the strongest reused or imported declaration's `dependency-neighborhood`, and adjacent `D5/` and `Blueprint/` modules. The workflow that produced a file does not own its mathematical source. `D5/S3/ConceptDynamics/Answering/` is reserved for mathematics about answerability, settlement, assertion registers, and answer rendering; it is not a default destination for Lean produced by this skill. Place each source in the smallest established subject domain, co-locating it with its primary abstraction when that agrees with the current taxonomy, and record the path decision before compilation.

Implement the missing composition through this ordered completion:

1. Build a `premise-map` that maps every useful declaration to the exact premise or intermediate consequence it supplies and lists empirical, interpretive, and metaphysical premises separately.
2. Use `G` to implement only the missing composition. If no `project-source` already supplies it, write `G` as `tracked-lean` in the smallest canonical module and run the `generalization-audit`; a conjunction of unrelated hits, a renamed theorem, a conclusion repeated as a hypothesis, hard-coded scenario data, or definitions chosen to make the conclusion reflexive is not completion.
3. Use `S` to apply `G` to exact `P`; classify it as `tracked-S` only after exact-statement, successful-build, and axiom-closure checks pass. For a broad question, separate interpretations and prove their boundary instead of forcing an ambiguous yes/no predicate.

On the reuse route, carry out Step 2's reuse decision: write the `S` application of the reused declaration to exact `P` in the smallest canonical specialization module with a matching canonical `Describe`, compile it through the current `make` door, retain it as `tracked-S`, and write no renamed `G`. On the new-`G` route, run `make help`, inspect current project structure, and measure compiler capability with current `make` doors and exit codes; never use a cold bare Lake command. Write `G` directly in the smallest canonical module with a matching canonical `Describe`, write `S` in a separate canonical specialization module with its matching canonical `Describe`, connect both to the import graph, and compile both `G` and `S`; retain a successful exact specialization as `tracked-S`. Before settlement, compile either a semantically distinct specialization of `G` or a nontrivial inhabited countermodel, verify that scenario-specific names and constants occur only in `S` or examples, and remove any unused hypothesis exposed by the audit. If that audit cannot distinguish `G` from a question-specific wrapper, keep the assertion `open` while retaining any successfully compiled exact `S`; do not delete the only proof or call the reusable gap complete. On the no-Lean route, which exists only for `not-formalizable` records, write no ornamental definition or scenario wrapper.

Capability failure is not evidence for or against `P`. A failed or unavailable compile leaves the formal result unsettled.

Postcondition: the record contains either an exact reused `project-source` plus its compiled `tracked-S`, the smallest substantive compiled abstract `G` ready for canonical retention plus its compiled `tracked-S`, a retained exact specialization whose reusable gap remains `open`, or explicit evidence for no formal result. Every successful exact specialization remains in project source, while search results and `tracked-S` alone never masquerade as a missing reusable inference.

### 5. Settle outcomes and freeze the answer register

Use one successful current `make` build and the exact compiled statements as the authority for any formal result. Reject evidence with `sorry`, a statement mismatch, a failed command, or a nonstandard axiom closure. Apply the first matching rule:

1. `not-formalized` when the record is `not-formalizable` and has no Lean statement.
2. `conditional` when compiled exact `P` is conditional on named empirical or metaphysical premises that remain undischarged.
3. `proved` when the successful build establishes exact `P` for any record not matched above.
4. `refuted` when the successful build establishes the exact negation of `P` for any record not matched above.
5. `open` otherwise, including ambiguity, unavailable compilation, failed proof, or no compiled declaration for `P` or its negation.

These ordered rules are exhaustive and single-valued by first-match evaluation. A failed proof never implies falsity, and a compiled conditional never discharges its real-world premises.

For a formalizable assertion not covered by an existing complete `project-source`, Step 4's compiled abstract `G`, applying `tracked-S`, and passed `generalization-audit` are preconditions for a settled formal result. Compilation of `tracked-S` alone earns retention but not settlement: it cannot bypass library growth, and the reusable gap remains `open`.

Emit one immutable internal settlement record per material assertion. It contains a unique record id, the stable assertion key, an explicit initial `active` status, the exact proposition, outcome, every undischarged condition, the unsettled reason where applicable, whether the claim is a formal result or a judgment, and the maximum permitted public claim. Set that maximum from the outcome: `proved` permits exact `P`; `refuted` permits exact negation of `P`; `conditional` permits only the consequent under every undischarged condition; `open` permits neither `P` nor its negation; and `not-formalized` permits only the recorded nonformal judgment, never a formal-grade claim. No outcome is allowed without an exact compiled proposition or an explicit record of its absence. Apply the local-settlement duty from `CLAUDE.md` item 5-double-prime; do not leave an elapsed task disguised as still progressing.

After any revision of `P` or `G`, append a validity delta that explicitly assigns `void` to each superseded active record for that assertion key, names every earlier settlement that still stands, and append a replacement settlement as `active`. The latest status assignment is the record's effective `active` or `void` status; never overwrite a record or delta, and keep exactly one active settlement per key.

Postcondition: every assertion key has exactly one active record with one outcome and one maximum permitted claim, while every record has an explicit effective `active` or `void` status in the append-only validity history.

### 6. Persist project source and account for the worktree

Apply the first matching route and stop at one:

1. `reuse-complete`: one existing declaration already proves the whole reusable `G` or canonical `P`, including every clause and boundary. Retain the compiled exact `S` application from Step 4 as `tracked-S` with its canonical `Describe`, cite the retained `project-source`, verify the retained tree with `make lean`, and stop persistence. Multiple adjacent hits that still require a deduction do not qualify.
2. `persist-generalization`: a new reusable `G` closes a genuine inferential gap, passes the `generalization-audit`, has a semantically distinct specialization or nontrivial countermodel, reuses existing declarations, and compiles without `sorry` or nonstandard axioms. Retain `G` as `tracked-lean` and its applying `S` as `tracked-S`, each in its canonical module with a matching canonical `Describe` source; the descriptions state the model's interpretive and empirical limits and include enough ordinary concept vocabulary for the same or an analogous future question to find them during `C`. Keep the required import-graph changes and verify the retained tree with `make lean`; use `make lean-report` only when the answer needs machine-readable closure.
3. `retain-specialization-open`: `S` successfully compiles exact `P`, but no existing complete `project-source` supplies the reusable inference and no new `G` passes the `generalization-audit`. Retain `S` as `tracked-S` with its canonical `Describe`, record why the reusable obligation failed, verify the retained tree with `make lean`, and keep the formal result `open`; retention records the exact proof without misclassifying it as reusable completion.
4. `discard-thin`: no source successfully compiles exact `P`, and the only new code is an import wrapper, ornamental definition, hard-coded question data that does not implement `P`, a theorem whose conclusion is assumed, or other `failed-or-uncompiled` material with no reusable value. Record the rejection evidence, remove only those unsuccessful artifacts, and keep the formal result `open`. A successfully compiled exact `S` never enters this route merely because it is scenario-specific.
5. `open-compile`: otherwise, including an unavailable compiler, failed elaboration, unresolved model, or nonstandard axiom closure. Preserve the exact source, command, exit code, and diagnostics in the current-run record as `open`; never report the proposition as proved.

Compare the worktree with its pre-run state. Recheck the `placement-audit` against the final imports, and relocate any misplaced successful source together with its canonical Describe rather than deleting it or routing it through `discard-thin`. Retain every successful new abstract `G`, every successfully compiled exact `S`, their canonical Describe sources, and required import changes; remove only failed, uncompiled, statement-mismatched, or ornamental artifacts with no reusable value. Useful generalization is not discarded merely because prose can answer or the current user did not ask to see code, and a specialization does not acquire `G` status merely by compiling, but exact successful compilation does earn `tracked-S` retention. If authorization does not permit a commit or pull request, leave all retained source present in the worktree and disclose the integration state; do not delete it to make the tree appear clean. Commit the coherent local unit only when repository policy and the user's request allow; never open or advance a pull request unless requested.

Emit an internal `side_effects` record containing the final project paths, the exact build command and exit code, the axiom output or report or an explicit reason none was produced, any other verification commands and exit codes, whether anything was committed, and the plain verification result. If nothing was written, record that fact and an empty path set without inventing a mutation.

Postcondition: persistence is settled, the final tree is accounted for, every discarded artifact lacks a successful exact compilation and is demonstrably valueless, every compiler failure is evidence-complete, every successfully compiled exact specialization is retained as `tracked-S`, and every successfully closed reusable gap is reachable through retained canonical `G` source so a later run can reuse it. `side_effects` describes the state and integration status that Step 7 will report.

### 7. Render the plain answer

For this skill's output, default to ordinary conversational prose. By default omit `P`/`G`/`S` labels, GIDs, proof-provenance module paths, build receipts, axiom closures, search traces, and the outcome-vocabulary words. This is not a repository-wide register policy.

The procedure directs the renderer one-way from the immutable Step 5 register to prose to reduce epistemic-strength leaks; it does not make the renderer strength-monotone. The register is its only epistemic input; it may not draft claims afresh from search hits, `G`, or `S`. Draft ordinary prose freely without a phrase table, then ask what a competent reader would take away from every heading, lead, body paragraph, and final sentence, including what is implied rather than stated, and translate that takeaway into propositions. Assertive sentences, presuppositions, definite descriptions, rhetorical questions, imperatives, sentence fragments, and conventional implicatures are non-exhaustive examples, not a closed list. Match each epistemic proposition to the unique active Step 5 record for its stable assertion key, never to a void record, and ask whether that active record entails it with no hidden premise. Match each repository-action proposition to the Step 6 `side_effects` record. If the competent-reader takeaway is unmatched or exceeds the active record's maximum permitted claim, reject and redraft it. For this audit, communicating any proposition stronger than an active `open` record's `P` counts as asserting `P`. Do not emit the answer while the worker has identified any stronger or unmapped item.

Enforce these scope rules during that audit:

- Put every material condition in the same sentence or grammatical scope as its consequent; a detached disclaimer does not count.
- For an unsettled proposition, redraft any wording from which a competent reader would take away `P` or its negation, including after "my judgment is." The forms named above are examples, not the boundary. Ground any practical recommendation separately and say that it does not settle the question.
- For a mixed summary sentence, qualify, split, or delete it until it does not exceed its weakest load-bearing clause. A clause is load-bearing when removing it changes which active record the sentence maps to.

Treat each active record's maximum permitted claim as the drafting ceiling: whenever the competent-reader test identifies an excess, reject and redraft it. The competent-reader takeaway, natural-language entailment, and no-hidden-premise checks are worker judgments, not decidable procedures; this prompt-level audit reduces the leak surface and blocks identified channels, but unbounded pragmatic conveyance means it cannot guarantee strength preservation. There is no lint behind it; do not claim machine-level enforcement.

Default suppression yields when it would hide a material condition, model boundary, unresolved ambiguity, compiler or axiom limitation material to the answer, persistent repository mutation, or an audit record requested for proof review, reproduction, debugging, or challenge. Expose the minimum formal detail the answer needs. When a formal predicate's ordinary-language name differs materially from its formal content, state in ordinary words what the term actually means there; a formal symbol or bare "within the model" does not suffice. Include excluded ordinary readings and material observer, world, and time indices whenever they change the answer. When the user requests the full record, which is the `show-work` mode of the conversation contract, append the current run's record after the plain answer verbatim; do not promise indefinite storage or later retrieval.

If Step 6 retained source, add one ordinary sentence naming every changed path, whether it was committed, and the plain verification result. This action disclosure is a narrow exception to suppressing proof-provenance paths and receipts. If nothing was written, claim nothing about repository mutation.

Postcondition: the answer reads like normal conversation; the worker has mapped its competent-reader takeaways, redrafted every strengthening or unmatched item the audit identified, kept all material limits visible, and accurately disclosed repository side effects. This records completion of the bounded judgment, not a guarantee that no pragmatic strengthening remains.

