The Voice Doctrine, Live

"A judgment record is only worth keeping if every entry is a decision someone actually made."

The Doctrine Is a First-Class Citizen

In a general-purpose editor, "voice rules" would be a plugin nobody installs. In Rekindle they're core, because voice is what the tool exists to protect. The doctrine — the traps, the register rules, the preferences learned from years of real corrections — is wired into the editing surface: underlined live while writing (Track 4), consulted by CMD+K, and weighed in a pre-publish read. It isn't an add-on to the spec; for a market of one, it is the spec.

The Judgment Ledger — Explicit Verdicts Only

The doctrine grows through a judgment ledger. When the voice underline flags a phrase, Dad can rule on it — and only that explicit verdict gets recorded, appended to a machine-local, append-only ledger, with exceptions filtering future detection live. What's deliberately excluded is the tempting part: passive inference. "He didn't change it, so he must agree" is not a verdict; it's a guess wearing a verdict's clothes. Letting guesses into a judgment record poisons the record — and a poisoned doctrine is worse than no doctrine, because you'd trust it.

// Only an EXPLICIT ruling is appended. No passive inference.
function recordVerdict(issue, verdict: "accept" | "reject") {
  appendToLedger({ rule: issue.rule, text: issue.text, verdict }); // append-only
  if (verdict === "reject") addException(issue); // filters detection live
}

// NOT recorded: "he left it alone, so it's probably fine."
// A guess in a judgment record is indistinguishable from a decision later.

Advisory, Never Blocking

The other half of the discipline: the doctrine advises, it never blocks. The pre-publish Pippa read gives a verdict chip on a draft, and it cannot stop you from publishing. A voice checker that could veto would quietly become the boss of the voice it's meant to serve — and the writer, not the checker, owns the voice. Same reason Pippa-proposes-new-rules is deferred by design: the doctrine grows from Dad's actual rulings, not from a model's suggestions about what his rules should be.

Code

Explicit verdicts only; exceptions filter detection live·typescript

// The ledger is append-only and machine-local.
// ONLY an explicit ruling from the writer is recorded.
function recordVerdict(issue: VoiceIssue, verdict: "accept" | "reject") {
  appendToLedger({ rule: issue.rule, text: issue.text, verdict });
  if (verdict === "reject") {
    addException(issue); // future detection skips this, live
  }
}

// Deliberately NOT recorded:
//   - "he didn't change it, so he must agree"  (passive inference)
//   - "Pippa thinks this should be a new rule" (deferred by design)
//
// Once a guess is in the ledger it's indistinguishable from a decision.
// A poisoned doctrine is worse than none — because you'd trust it.

Exercise

Design a tiny judgment ledger for one of your own rules (from the Track 4 exercise). Decide exactly what gets an entry and what doesn't. Then write down the one inference you're tempted to record ('they kept it, so they liked it') and explain, in one line, why letting it in would eventually make the whole ledger untrustworthy.

Hint

The corruption is silent and irreversible: a month later, an inferred row and a decided row look identical, so every conclusion drawn from the ledger inherits the guess. The only defense is refusing the inference at write time — you can't clean it out later, because you can't tell which rows were guesses.