Lesson 170: Executive Readback Redlines Versus Partner Annex FAQ Discipline (2026)

Direct answer: The most expensive partner trust failure on a small 2026 OpenXR team is not a wrong number — it is the same number being explained two different ways in the board pack and the partner annex. This lesson teaches FAQ discipline: every common executive redline (the questions leadership keeps asking on every readback) gets a single tracked FAQ row, bound to the metric dictionary IDs from Lesson 164, surfaced inside both the executive readback projection and the partner annex, and protected by a forbid-silent-rewrite gate in the same checkpoint cadence you rehearsed in Lesson 169.

Panda and Fox friendship illustration symbolizing leadership-and-partner alignment through one shared FAQ source of truth

Why this matters now (2026)

In early 2026, board packs and partner audit PDFs started diverging on small Quest cert teams not because anyone lied but because the FAQ lived in email. Leadership would ask "why is buffer lane B still red" in Slack; the response would land in a follow-up message; the next board pack would re-explain it differently; the partner annex would reuse last week's answer. Three cycles later, the same metric buffer_lane_b_forecast had four explanatory paragraphs in circulation, two of them now inconsistent with the dashboard tuple.

The fix is not "write better emails." The fix is to treat FAQ rows as first-class governance data, give each row a faq_row_id, bind it to a metric_dictionary_id from Lesson 164, version it like the metric dictionary itself, and refuse to render the executive readback or the partner annex if any unbound or stale FAQ row is referenced. That makes FAQ as audit-grade as the burn-down or the tuple itself.

Pair this lesson with the Unity preflight chapter Unity 6.6 LTS OpenXR Governance Executive Readback Redlines Versus Partner Annex FAQ Discipline Preflight so the editor-side data shape stays consistent with the BI-side readback projections.

When a partner cites a redline you do not recognize, route to OpenXR governance replay fails because partner SLA transparency snapshot totals disagree with leadership dashboard rollup - fix before you rewrite the FAQ - the dashboard tuple has to agree first.

Prerequisites

Lesson 162 SLA breach forecasting, cert-window freeze gates, and pre-window staffing buffers
Lesson 163 freeze bypass audit trails and carve-out annex footers
Lesson 164 leadership and partner SLA dashboard sync; shared metric dictionary; executive readback projections
Lesson 165 governance packet footer metadata schema semver and replay parser contract
Lesson 168 staffing buffer burn-down visibility on leadership dashboard slices
Lesson 169 freeze lift rehearsal dry run coupling to dashboard snapshot tuples

Outcome for this lesson

You will implement:

A FAQ table keyed by faq_row_id, with metric_dictionary_id, metric_dictionary_revision, question, answer_short, answer_long, owner, last_reviewed_utc, and status.
A bind contract that refuses to render the FAQ row unless its metric_dictionary_id resolves at the same metric_dictionary_revision as the surrounding readback or annex packet.
A forbid-silent-rewrite gate that compares the published answer_short against the prior tuple's answer_short and refuses to swap text without a versioned change record (faq_change_id) and signer ack.
A redline registry that tracks recurring exec questions and the FAQ row currently bound to each.
A same-checkpoint cadence that walks FAQ refresh through the dashboard tuple → partner annex → executive readback projection in the order Lesson 169 rehearsed.

The FAQ data shape

Build a single source-of-truth table in the same database the Lesson 164 metric dictionary lives in. The table:

faq_rows
  faq_row_id              # stable string id, e.g. "faq.buffer_lane_b_forecast.why_red"
  metric_dictionary_id    # e.g. "buffer_lane_b_forecast"
  metric_dictionary_revision  # semver bound at the time the row was last reviewed
  question                # the exact redline as leadership phrases it
  answer_short            # one-paragraph readback answer; appears in board pack
  answer_long             # one-page partner annex answer; appears in partner PDF
  owner                   # named human; not a team
  last_reviewed_utc
  status                  # 'active' | 'retired' | 'pending_review'
  faq_change_id           # latest change record bound to a signer ack

Rules:

faq_row_id is stable. Once minted, never edited. If the question changes, mint a new row and retire the old one.
One row per (metric_dictionary_id, question) pair. Two rows answering the same question on the same metric is the precise bug this lesson fixes.
metric_dictionary_revision is captured at review time. If the metric dictionary moves to a new revision, the FAQ row goes to pending_review and the readback flags it - the question may now mean something different.

The bind contract

When the executive readback projection or the partner annex packet references a FAQ row, the renderer must:

Resolve faq_row_id to a row.
Confirm the row's metric_dictionary_id resolves in the metric dictionary at the same revision the surrounding packet is using.
Confirm the row's status is active.
If any check fails, render the FAQ block as a red banner: "FAQ row not bound at this revision. See change record faq_change_id."

This is the same fail-closed pattern as the Lesson 169 dry-run block. Reviewers cannot ignore a banner; they routinely ignore an out-of-date paragraph.

The forbid-silent-rewrite gate

Most of the trust damage happens not when a row is missing but when answer_short silently changes between board packs. The gate prevents this by:

Storing the previous answer_short alongside each row update.
On publish, comparing the new answer_short to the prior version.
If different, requiring a faq_change_id referencing a change record with a signer ack from the same owner.
If the change has no signer ack, the publish fails closed and the readback projection refuses to render the row.

Example gate (pseudocode):

def gate_faq_publish(faq_row, prior_faq_row):
    if faq_row.answer_short != prior_faq_row.answer_short:
        if not faq_row.faq_change_id:
            raise PublishBlocked(
                f"FAQ row {faq_row.faq_row_id} answer_short changed without change record"
            )
        change = load_change(faq_row.faq_change_id)
        if not change.signer_ack or change.signer_owner != faq_row.owner:
            raise PublishBlocked(
                f"FAQ change {faq_row.faq_change_id} missing or wrong-owner signer ack"
            )
    return True

This is deliberately strict. The cost of forbidding a silent rewrite is one signer ack. The cost of allowing one is a partner audit RFP question you cannot answer in writing.

The redline registry

Even with the FAQ table in place, leadership keeps asking the same handful of questions on every readback - the redlines. Track them explicitly:

redlines
  redline_id              # e.g. "redline.cert_week_buffer_b"
  question_template       # canonical phrasing of the redline
  current_faq_row_id      # the FAQ row that currently answers it
  last_observed_utc       # when leadership last asked it
  observed_count
  status                  # 'open' | 'retired'

Workflow:

After every executive readback, append observed redlines (with timestamps) to the registry.
If a redline maps to no current_faq_row_id, the readback dashboard surfaces it as unbound - someone has to mint a FAQ row or retire the redline.
The partner annex includes the bound FAQ rows for every redline observed in the last two windows, in the order of observed_count.
The executive readback uses the same ordering. Leadership and partners read the redlines in the same priority order.

Same-checkpoint cadence

Pair the FAQ refresh with the Lesson 169 dry-run sequence so leadership and partners get the same FAQ revision in the same minute:

Dashboard tuple advance (Lesson 164) - if metric dictionary moves, FAQ rows depending on the touched metric_dictionary_id go to pending_review automatically.
FAQ review window - the owner has a fixed time (default 24 hours) to either confirm the row at the new revision (signed ack) or mint a successor row.
Partner annex render (Lesson 164) - includes only active rows at the current revision.
Executive readback projection (Lesson 164) - includes the same row set in the same order.
Freeze-lift dry run (Lesson 169) - the dry_run_id block lists which redlines now resolve at the new revision and which are still pending_review. If any redline is unbound, the freeze cannot lift.

This is the bonded chain: dictionary → FAQ rows → partner annex → executive readback → lift rehearsal.

Worked example

A cert-week board pack has this redline:

Leadership question: "Why is buffer lane B still red after the carve-out from Lesson 163 cleared?"

Without FAQ discipline, the answer drifts:

Week 1 board pack: "Carve-out closed but rollup includes day -2."
Week 2 board pack: "Partner annex shows day -2 in the snapshot."
Week 3 board pack: "Source spreadsheet had a pinned cell that flipped on Tuesday."

All three answers are partially right, and they make the team look like they are guessing.

With FAQ discipline, the answer is one row:

faq_row_id: faq.buffer_lane_b_forecast.why_red
metric_dictionary_id: buffer_lane_b_forecast
metric_dictionary_revision: 4.2.1
question: "Why is buffer lane B still red after the carve-out cleared?"
answer_short: "Forecast model still includes the carve-out window minus two days
              of partner annex lag. See change record faq.20260509."
owner: [email protected]
last_reviewed_utc: 2026-05-09T14:22:00Z
status: active
faq_change_id: faq.20260509

Every board pack quotes this row. The partner annex quotes this row. If metric_dictionary_revision advances to 4.3.0, the row goes to pending_review and a renewal pass mints a new faq_change_id.

The redline registry counter advances each week leadership asks the question. When the count reaches a threshold (say three windows in a row), the registry surfaces it as a structural redline - the burn-down or buffer model itself probably needs a Lesson 162 revision, not a FAQ update.

Acceptance criteria for this lesson

[ ] faq_rows table created with the eight required columns and FK to the Lesson 164 metric dictionary.
[ ] Bind contract enforced in the executive readback projection and the partner annex renderer (both fail closed on missing row, wrong revision, or non-active status).
[ ] Forbid-silent-rewrite gate blocks publishes that change answer_short without faq_change_id and matching-owner signer ack.
[ ] redlines table tracks observed exec questions; unbound redlines surface on the readback dashboard.
[ ] Cadence wired: dictionary revision → FAQ pending_review → partner annex → executive readback → freeze-lift dry-run block.

Troubleshooting

FAQ rows keep going `pending_review` after every metric dictionary patch

That is the system working. Most metric dictionary patches are additive (Lesson 165); the FAQ row owner can confirm at the new revision in under a minute. If your team cannot keep up, the dictionary churn itself is the bug - rate-limit dictionary publishes to the same cadence as readbacks.

Two FAQ rows answer the same redline differently

Use the redlines table to pick one as canonical and retire the other. Do not silently merge. Mint a faq_change_id that records both prior rows and the merged canonical row; bind the signer ack to the merger.

Owner is a team, not a human

That is the cause of most rewrites. FAQ rows must be owned by a named human. The team routes through the human; the human owns the publish gate.

Leadership asks a redline that maps to no metric

That is a higher-order signal: the question is about a process or person, not a metric. Add a redline.metric_dictionary_id = null row and route it to your Lesson 160 retro process; do not mint a FAQ row that pretends a metric exists.

Partner annex still differs from board pack

Likely the renderers are reading the FAQ table at different times. Pin both renders to the same metric_dictionary_revision and the same faq_publish_run_id (use the Lesson 166 weekly reconciliation job_run_id if you already have it).

Pro tips

Cap answer_short at 400 characters. Anything longer drifts as it gets edited. Push detail into answer_long, which lives in the partner annex.
Pre-mint FAQ rows for the five redlines you predict before the first cert window. Leadership asks the same five things every week; locking those rows on day one prevents the silent rewrite cycle from ever starting.
Include the faq_row_id in the executive readback as small inline ID text. Signers learn to cite IDs in their acknowledgments, which closes the loop with the redline registry.
Treat FAQ retirement seriously: a retired row is immutable. Future readbacks can quote the retirement record (faq_change_id) when partners ask "why does the old answer not appear anymore."

Key takeaways

FAQ is governance data. Treat redlines like metrics: bind, version, sign, retire.
Forbid silent rewrites. Every answer change needs a change record and an owner ack.
One row per redline. Two rows answering the same question is the bug.
Same checkpoint, same revision. The FAQ row, the dashboard tuple, the partner annex, the executive readback, and the freeze-lift dry-run must all agree at the same metric_dictionary_revision.
Track unbound redlines. Questions leadership keeps asking without a FAQ row are the structural signal worth investigating - usually a missing or churning metric.

FAQ

Does every executive question need a FAQ row?
No. FAQ rows exist for redlines - recurring questions across windows. One-off questions live in retro notes (Lesson 160), not in the FAQ table.

What happens if leadership rewords the same redline next week?
The redline registry's question_template is canonical. If leadership rewords, the FAQ row stays the same and the registry logs both phrasings. The change is only "real" when the meaning changes, not the wording.

Can AI assist with drafting answer_short?
Yes, in a strict pattern: AI proposes a draft, the owner edits, the gate requires the owner's signer ack. The AI never publishes. Pair this with the human-gated AI patch notes workflow for the same human-in-the-loop discipline.

Does this slow down the readback cadence?
A locked FAQ row is faster than email. The first cert window costs an hour to mint five rows; every subsequent window costs minutes because the rows already exist.

What if the partner annex needs a longer answer than the board pack?
That is what answer_long is for. The bind contract guarantees both fields advance together at the same revision; they cannot drift.

Next lesson teaser

Continue with Lesson 171 - Tuple Drift Automatic Block on Dashboard Publish Pipeline (2026) to add a hash-comparison gate to the dashboard publish pipeline so async edits to source sheets during 2026 crunch weeks cannot push a stale tuple through CDN or SharePoint distribution before the FAQ-bound readback has caught up.

Continuity:

The reason small teams lose partner trust is rarely a wrong number; it is the same number explained two different ways at the same minute. Bind every redline to one FAQ row, refuse to rewrite the answer without a signer ack, and the explanation drift that has eaten dozens of partner audits silently in 2026 stops at the gate.