Writing Intelligence v8 — Story Intelligence on the Sovereign Meaning Runtime

Author: Antonio T. Smith Jr. — Founder & CEO, Density6 LLC License: MIT Version: 8.0.0 Lineage: v1.0 (7-pass compiler) → v2.0 (Fiction Intelligence Engine) → v3.0 (11-pass governed kernel) → v4.0 (accountability layer + deterministic verification) → v5.0 (semantic identity, dependency graph, proof-carrying release) → v6.0 (executable meaning — branches, authority, simulation, conflict-preserving merge) → v7.0 (Institutional Intelligence — authentic authorship, receipt-governed program for consequential work) → v8.0 (Story Intelligence — 340 fiction requirements across four offline engines: fiction & thriller, arc & ending, the craft, Japan Story OS)

v8 in one paragraph

v8 is Story Intelligence — the fiction half of this system brought up to the standard v4–v7 built for evidence. It folds four independently built and independently tested packages into one release: Fiction & Thriller Intelligence (60 requirements, FI-01–FI-60 / B001–B060 — tension, rule integrity, power limits and cost, promise debt, reader experience), Arc, Want/Need & Ending Intelligence (N061–N120 — two-clock character state, want/need versions, the sweet / semi-sweet / bittersweet / bitter ending algebra, arc family kept independent of ending result), The Craft (C121–C180 — openings, action geometry, antagonistic causality, suspense contracts, mixed sequence outcomes, dated reference hygiene) and the Japan Story OS (JP-181–JP-340 — cultural claims scoped by place, period and source, folklore variants that coexist, name and romanization policy, a private author vault for young writers, release preflight). 340 numbered requirements, each with a stable ID, an owner, an acceptance condition and an honest implementation state. Every engine is offline, stdlib-only Python, read-only against the manuscript, deterministic, and digest-bound.

The v8 rule: a structural pass is not a good novel. Mechanical consistency, interpretive signal, human editorial judgment and independent reader reception are four different states and are never coerced into one another. Every publication gate in v8 holds — HOLD (exit 3), and the Japan Story OS preflight refuses with exit 2 — until a human editor and real readers have spoken, by design. A need is an interpretation attributed to a person, never a model's access to a character's soul; a cultural fact needs a scoped source, a fictional canon needs an author's adoption, and missing information stays missing.

What 8.0.0 ships, and what it does not. Shipped, with receipts in plans/receipts/WI8-R*.json: the four engines installed additively (zero collisions, no v4–v7 file changed in behaviour), their own suites passing inside this repository, every v4–v7 regression unchanged, and a third installable bundle, writing-intelligence-story, that carries them. Planned, and said so: canonical integration into wi.py and the v6 semantic graph, full-manuscript extraction, reader trials and cultural review — waves FI8-03–06 and WI8-00–WI8-43 in plans/v8.manifest.yaml. Index: references/v8/README.md.

v8 commands (run from the repository or the writing-intelligence-story bundle)

python3 scripts/wi-fiction.py audit --input story.json        # FI-01..FI-60 fiction & thriller audit
python3 scripts/wi-fiction.py text-signals --text chapter.txt # pattern signals, never verdicts
python3 scripts/wi-arc.py classify --want attained --need unfulfilled  # -> bittersweet
python3 scripts/wi-arc.py evaluate --input arc.json           # two-clock arc and ending check
python3 extensions/wi8/craft03/scripts/wi-craft.py evaluate --input scene.json
python3 extensions/wi8/japan04/cli/wi8_japan.py check project.json
# wi-fiction `gate --mode publication` and wi-arc / wi-craft `gate --stage publication` exit 3 (HOLD) by design;
# wi8_japan `preflight` exits 2 — a preflight is never an authorization

Exit codes across all four: 0 analysis ran or mechanical-only pass, 2 malformed input or structural block, 3 editorial or publication hold.

v7 in one paragraph

v7 is the Institutional Intelligence Expansion (program WI7-IIP): the work whose consequences are academic, legal, financial, contractual, regulatory or institutional — dissertations, filings, investor rooms, grants and bids. 7.0.0 ships the governance, not the domain workflows. It froze the baseline, proved v4/v5/v6 reproduce exactly (3/32/70 assertions, byte-identical bundles), repaired the academic doctrine so no pack instructs detector evasion or fabricated authorship, and made the program checkable: a wave in plans/v7.manifest.yaml is shipped only with a PASS receipt carrying its command, result, negative control and independent readback. The doctoral, legal, capital, grants, procurement and deal workflows are waves WI7-03 to WI7-19, all planned — say so when asked, and never present one as working. Program: references/v7/INSTITUTIONAL_INTELLIGENCE_PROGRAM.md. Why this is "v7": references/v7/RFC-0001-VERSIONING.md.

The v7 rule for consequential work: proof is not outcome. A document can be verified; an admission, award, filing, financing or verdict is claimed only from the institution's own evidence. And in academic work the author's own thinking stays visible — observations come from the author, uncertainty is real, and required AI-use disclosure is drafted, never suppressed.

v6 in one paragraph

v3 governs how well the writing is built. v4 governs what may be claimed about it. v5 governs what depends on what. v6 governs what may become true, who may make it true, and what it costs. The eleven passes, twelve engines, genre packs, voiceprints and anti-slop doctrine below are unchanged and remain the craft core. The v4 laws A–F and the v5 laws G–L are unchanged and remain in force. v6 adds a state machine on top of the graph: a document is a build of governed meaning rather than the meaning itself, a change is proposed before it exists and simulated before it is accepted, an acceptance is bound to the exact state a human actually reviewed, authority is scoped and expires, and disagreement between two versions is preserved as a typed conflict rather than smoothed into a third claim neither side made.

The v6 law: No consequential state transition may become authoritative unless the system can identify the exact prior state, proposed next state, semantic delta, dependency impact, acting authority, decision basis and resulting proof closure.

Start here: the five questions

Ask these before writing anything. They set every downstream default and they are cheap compared to rebuilding.

1. What must become true after someone reads this? The mission. Everything else serves it.
2. What evidence mode applies? See below. This is the single highest-leverage answer.
3. Whose voice is this in, and do we have a sample? A voiceprint measured from real text beats an adjective every time.
4. Who is the reader, and what could they challenge? Anticipated objection is structure, not decoration.
5. What happens if a number, date or source in this changes six months from now? If the answer matters, work in a workspace and the graph will answer it for you.

Evidence mode (question 2)

When in doubt, pick the stricter one. Downgrading is a decision someone can make later with the evidence in front of them. Upgrading after the fact means re-doing the work.

The eighteen laws

Six from v4, six from v5, six new in v6. None of them have been softened.

v4 — accountability

v5 — dependency

v6 — meaning as state

The unit changed twice

v4 checked sentences. v5 checked claim atoms — one independently checkable assertion, so a sentence carrying four facts fails on the one that is wrong instead of being marked "unsupported" as a whole.

v6 changes what an atom lives in. An atom is no longer a row in a ledger attached to a document. It is a node in a versioned semantic graph that several documents may render at once. Change the node once and the graph names every place it surfaces.

Claim status vocabulary

The v6 workflow

Craft first. Governance second. In that order, always — a beautifully governed document that does not do its job is a failure with an audit trail.

1. Passes 0–11 build the writing. Nothing below replaces this.
2. wi init — create a workspace when the work is consequential or long-lived.
3. wi ingest — content-address every source. Raw bytes are the identity.
4. wi atomize → wi anchor — bind claims to exact spans and run the deterministic checks.
5. wi propose — a change is written against an exact state. Nothing has moved yet.
6. wi simulate — what would this do? What breaks, what must be re-proved, who has to approve it, what does it cost, and what is provably untouched. Still nothing has moved.
7. wi decide — an actor with a valid grant accepts or rejects. The decision is bound to the state they actually saw.
8. wi commit — every accepted proposal applies as one transaction.
9. wi obligations → wi gate — what must be proved before this ships, then the verdict.
10. wi bundle / wi capsule — a proof-carrying release, or a selectively disclosed capsule for someone who may not see the whole vault.
11. wi verify-release — a stranger verifies it offline, with no model and no network.

When a branch and a merge are involved: wi branch create → work → wi merge. A quantity conflict stops there and stays visible. That is the feature.

Executable tier

Everything in this block runs today, offline, on stdlib-only Python 3.8+, in scripts/wi.py. Nothing here calls a model.

# v4 floor — works on any single file, no workspace needed
wi preserve draft.md                     # snapshot before editing (Law B)
wi scan-sources sources/                 # injection indicators and hidden text
wi extract-claims draft.md --out c.json  # sentence-level claim ledger
wi verify c.json sources/                # span lock, quotation, numeric, date
wi gate c.json --mode strict --exit-code # RELEASE / HOLD / BLOCK

# v5 — meaning, dependency, proof
wi init --title "Project" --mode strict
wi ingest sources/
wi atomize manuscript/
wi anchor
wi graph
wi impact sources/report.txt --apply      # what broke, and what provably did not
wi diff old.md new.md --semantic
wi explain chapter.md:412
wi bundle out/release.wiab
wi verify-release out/release.wiab

# v6 — meaning as state
wi canon object.json                      # canonical form, domain-separated digest
wi branch create what-if/target-95 --switch
wi propose --node promise-13 --payload new.json --why "statutory target moved"
wi simulate --actor antonio               # writes nothing
wi authority issue --subject antonio --capability claim.accept --scope workspace
wi decide PROPOSAL_ID --accept --actor antonio
wi commit -m "raise the completion target"
wi log
wi merge audit                            # conflicts are preserved, never averaged
wi conflicts --resolve ID --take ours --actor antonio
wi obligations --mode strict
wi as-of --valid-at 2026-12-31 --known-at 2028-03-14T09:22:41Z
wi constraints                            # the graph constraint engine, C001..C020
wi capsule create --out claim.wic --select promise-13 --profile selective
wi capsule verify claim.wic
wi why promise-13

Exit codes on gate --exit-code are 0 RELEASE, 1 HOLD, 2 BLOCK. A refused transition — no grant, expired grant, stale decision, unresolved conflict — exits 2 and names the error code.

The four things to reach for first

• `wi simulate` is the command that changes how the work feels. It answers what would this do before the change exists, and it reports the provably unaffected remainder with the same prominence as the breakage. Use it before every consequential edit.
• `wi merge` on a quantity disagreement will stop and show both numbers. Do not look for a flag that makes it pick one. There isn't one, on purpose.
• `wi why` runs backward from a sentence to its basis, the commit that introduced it, and the grant that permitted it.
• `wi capsule` hands a regulator, funder or partner proof of one claim without handing them the whole source vault — and states, in the artifact, exactly what a redacted leaf does and does not prove.

What is specified and not executable

Law C applies to this file as strictly as to anything it governs. The following are designed and normatively described in references/v6/. None of them run. Nothing in this repository executes them, and any document implying otherwise is a defect.

• The compiled Rust core and its WASM build. scripts/wi.py is the canonical core. There is no compiled core and no daemon.
• Compiler backends. Meaning does not yet compile to .docx, PDF, HTML, slides or subtitles, and there are no render source maps.
• The judgment tier. No provider ships. Where doctrine describes what a provider must record, it is binding a future implementation, not reporting one.
• Sandboxed ingestion adapters and the WASM plugin host. PDF, XLSX, DOCX, image, audio and video anchors are specified only.
• External signing, semantic remotes, signed graph deltas, federation and watch mode.
• The Workbench, REST v6 and MCP v6.

A capsule built by this core says so itself, in declared_omissions. A missing capability is declared, never guessed.

v6 reference map

The v5 layer remains authoritative for its own subject matter: references/v5/ — the authorship graph, evidence anchors, staleness, semantic diff, reliability types, proof-carrying release. So does v4: references/v4/.

What this refuses to do

The refusals are load-bearing, not decorative. Full reasoning in references/v6/NON_GOALS.md.

• Detector evasion. Anti-slop is a craft objective — prose that does not pattern-match to machine writing because it is genuinely better built. It is not a laundering service.
• Source generation. It will never construct a citation. If a claim needs support and none exists in the supplied material, the output is needs_source. Inventing a plausible reference is the single most damaging thing this system could do.
• Truth verification. It verifies support within the sources supplied. It cannot tell you the source is right.
• Absolute quality scores. Scores are relative to a stated profile, arena and mission. There is no universal writing number, and there is no overall health gauge.
• Similarity as evidence. Retrieval finds candidates. Only comparison produces proof. High similarity is never support.
• Hidden auto-merge of consequential state. If meaning conflicts, the conflict is preserved.
• Renderer-side facts. A renderer that needs new meaning emits a proposal and stops.
• History rewriting. A correction supersedes an old state. It does not falsify the record of what was known.

The companion packs

Three bundles in v8. writing-intelligence (this runtime), writing-intelligence-craft (the craft library below, which now also carries the v8 fiction compiler references and genre addenda), and writing-intelligence-story (the four v8 story engines, their rules, schemas and suites). Install all three; each stands alone, and each is under the 200-file ceiling.

The craft library — 27 genre packs, the voiceprint corpus, anti-pattern and positive-pattern detectors, the compiler references and the diagnostic set — ships as a second installable bundle, writing-intelligence-craft. This is not a downgrade. A skill bundle may hold at most 200 files, and a bundle that exceeds it does not degrade, it simply does not load — which would make every install instruction in this repository false. Splitting the runtime from the library is what keeps both under the ceiling with room to grow.

Install both. If only this one is present, the craft doctrine summarized below still governs; the genre packs are then reference material one git clone away rather than in context.

The v3 craft corpus below — genre packs, voiceprints, anti-patterns, compiler references, the twelve agents — is unchanged and remains the authority on how the writing itself gets built.

Writing Intelligence v3.0 — The Craft Kernel

Author: Antonio T. Smith Jr. — Founder & CEO, Density6 LLC License: MIT Version: 3.0.0 (Sovereign Writing OS) Lineage: v1.0 (7-pass compiler, 52 files) → v2.0 (Fiction Intelligence Engine, 58 files) → v3.0 (11-pass governed kernel, 12 engines, 12 agents, schemas, benchmarks, governance)

0. What v3.0 Is

v1.0 proved AI-sounding prose can be defeated by compilation instead of cosmetic cleanup. v2.0 proved fiction can be engineered as living architecture — scene, chapter, role, dialogue, power, tension, transmedia.

v3.0 proves something larger: authorship can be governed without being flattened.

Writing Intelligence v3.0 is no longer only a writing skill. It is an operating system for producing, auditing, scoring, preserving, and deploying high-integrity writing across genres, voices, teams, products, and longform worlds. It runs as one skill or as a coordinated multi-agent writing board. It emits human-readable scorecards and machine-readable JSON. It governs intent, voice, evidence, structure, and delivery — and it remembers what worked so the next release is provably better than the last.

The v3.0 Law: If a rule cannot be applied, audited, scored, tested, or explained — it is not a v3.0 rule yet.

1. The v3.0 Formula

Intent → Corpus → Voice → Genre → Architecture → Evidence → Prose → Scene/Argument → Stress → Score → Delivery → Memory → Benchmark

2. Architecture: 11-Pass Compilation Kernel

Every piece of writing processed by v3.0 runs through eleven sequential passes. Passes may be skipped only by explicit reason. Each pass leaves an audit artifact. Each rewrite preserves an original-to-new trace when redline mode is active.

2.1 Pass-Level Execution Rules

• Every pass must be skippable only by explicit reason.
• Every pass must leave an audit artifact.
• Every score must identify the rule it came from.
• Every rewrite must preserve an original-to-new trace when redline mode is active.
• Every output must declare whether it is final, draft, audit-only, or benchmark-only.
• Every claim must be classified before it is strengthened.
• Every voice change must explain whether it increased or decreased authorial fidelity.

2.2 Pass 0 — Intake Contract

Read references/compiler/intake_contract.md and emit schemas/intake_contract.schema.json-shaped object. Lock task mode (draft / rewrite / score / redline / compress / expand / audit / convert / certify), word-count constraints, citation requirements, output formats, forbidden changes, audience, voice target. User-provided constraints override auto-detection.

2.3 Pass 1 — Mission Lock

Declare:

• Intent: inform / convert / warn / teach / dignify / dominate / comfort / reveal / mobilize / persuade / entertain / defend / terrify / disorient
• Audience: vocabulary, abstraction, evidence expectations
• Voice: voiceprint from references/voiceprints/
• Genre stack: one or more packs from references/genre_packs/
• Scale: sentence / paragraph / scene / chapter / arc / series
• Success condition: one sentence describing what "worked" looks like

2.4 Pass 2 — Corpus & Context Ingestion

Read references/compiler/corpus_governance.md. Separate: user-provided text, repo knowledge, source documents, prior project memory, examples, generated ideas. Mark source priority. Flag stale, contradictory, unsupported claims. Block invented source attribution. Emit CorpusMapV3.

2.5 Pass 3 — Diagnostic Scan

Read references/anti_patterns/phrases.md, structures.md, cadence.md, fake_depth.md. Identify:

• AI residue (phrases, structures, cadence patterns)
• Contradictions within the text
• Vagueness (claims without actors, actions, stakes, specifics)
• Cadence repetition (sentence-length uniformity, transition homogeneity)
• Argument gaps (unsupported claims, missing premises)
• Evidence gaps (assertions without backing)
• Tone drift (sections that shift register without cause)
• Perplexity flatness (vocabulary predictability across paragraphs)
• Burstiness deficit (lack of sentence-length variance)

2.6 Pass 4 — Architecture Compile

Read references/compiler/architecture_graph.md (sections, paragraphs, claims). For narrative work, also read references/compiler/scene_graph.md. For persuasive work, also read references/compiler/argument_graph.md. Build the graph. Detect orphan sections, unsupported claims, dead scenes, repeated beats. Emit ArchitecturePlanV3.

2.7 Pass 5 — Evidence & Epistemic Ledger

Read references/compiler/epistemic_ledger.md. Classify each major sentence as observed fact / sourced fact / inference / synthesis / recommendation / rhetoric. Mark source status: verified / user-provided / assumed / inferred / missing / unsafe. Cap scores for unsupported claims, fabricated citations, universal language. Emit EpistemicLedgerV3. No high-stakes output may pass v3.0 without claim classification.

2.8 Pass 6 — Sentence Surgery

Read references/compiler/prose_compiler_v3.md. Apply hard bans, soft bans, earned exceptions. Inject variance. Compress without loss. Track every transformation in SentenceSurgeryLogV3. Every cut, strengthening, and preservation is recorded.

2.9 Pass 7 — Voice Restoration

Read references/voiceprints/voice_fingerprint_engine.md + the applicable voiceprint. Measure baseline: avg sentence length, variance, compression, abstraction tolerance, metaphor density, question frequency, transition habits, dominant syntactic structures. Detect drift. Restore fingerprint. Emit VoiceMatchReportV3 showing whether fidelity increased or decreased.

2.10 Pass 8 — Genre & Arena Alignment

Read references/compiler/arena_delivery.md + each active pack from references/genre_packs/. Resolve genre collisions per references/diagnostics/genre_collision_matrix.md. Output as memo, grant response, sermon, caption, article, chapter, email, pitch slide, YouTube script, newsletter, government brief, SOP, speech, landing page. Enforce channel constraints. Emit ArenaAlignmentV3.

2.11 Pass 9 — Adversarial Stress Battery

Interrogate:

1. What would a skeptical, smart reader attack first?
2. What sentence could appear in any AI output?
3. What could be cut without losing meaning?
4. What line actually lands?
5. Does the opening earn the next 30 seconds?
6. Does the closing leave residue?
7. Is there a single sentence a human would never write this way?
8. (Narrative) Would a reader turn the page?
9. (Narrative) Does the final image burn?
10. (Dialogue) Can you tell who's speaking with names removed?
11. (High-stakes) What is the worst-faith reading of the strongest claim?
12. (Detector) Could a detector flag any passage on cadence alone?

Emit StressBatteryV3.

2.12 Pass 10 — Score & Delivery Packaging

Apply all applicable scorecards (see Section 4). Bundle outputs per Pass 0 contract: clean / annotated / redline / scorecard / violations / scene-audit / epistemic-ledger / next-pass. Emit DeliveryBundleV3.

2.13 Pass 11 — Memory & Benchmark Update

Update project memory (references/compiler/memory_system.md). Append benchmark result. Run regression matrix against prior version. If quality dropped > 3 points on any case, log to tests/regression_matrix.md and surface for review. Emit MemoryBenchmarkUpdateV3.

3. The 12 Engines of v3.0

4. Scoring Systems (v3.0)

v3.0 preserves and extends the seven v2.0 rubrics, then adds a v3-grade composite.

Grade Thresholds (per 100-point system):

• Below 70 — Weak: significant revision required
• 70–79 — Usable but soft: tighten argument and voice
• 80–89 — Strong: publishable with minor polish
• 90–94 — Elite: distinctive, defensible, memorable
• 95–100 — Signature-grade: this could only have come from this author

Automatic Fail Conditions (score capped at 65 regardless of other marks):

• 3+ hard-ban phrases detected
• Perplexity flatness across 5+ consecutive sentences
• Zero domain-specific vocabulary in 500+ words
• Argument contains unsupported universal claim
• Fabricated citation, statistic, or quote
• (v3.0) Any claim in a high-stakes domain not classified by the Epistemic Ledger
• (v3.0) Channel constraint violation in a packaged delivery bundle

5. The Writing Board — 12 Specialist Agents

v3.0 decomposes the kernel into a coordinated multi-agent writing board. Each agent owns one job and emits one artifact. The board runs as one skill or as a multi-agent orchestration. Read agents/agent_manifest.yaml for the canonical roster.

5.1 Orchestration Rules

• Intake Architect always runs first.
• Corpus Auditor always runs when sources matter.
• Evidence Prosecutor always runs in academic / medical / legal / government / grant / financial / high-stakes work.
• Narrative Architect runs only for fiction / story / screenplay / scene / lore / transmedia / chapter work.
• Scorekeeper cannot override Evidence Prosecutor's cap rules.
• Delivery Packager cannot invent content; it formats approved content only.

5.2 Conflict Resolution

6. Genre Packs (26 Total in v3.0)

Preserved from v2.0 (16): strategy, fiction, sales, academic, speech, sermon, email, pitch_deck, legal_positioning, cinematic_narration, dialogue, government_brief, medical_writing, patent_claims, thriller_scene_architecture, transmedia_character.

New in v3.0 (10):

Each v3.0 pack obeys the Domain Pack Schema: purpose → when to use → when not to use → audience model → required evidence → forbidden claims → voice weighting → structure templates → scoring adjustments → failure modes → before/after examples → stress tests → delivery formats → schema hooks → benchmark cases.

7. Voiceprint System (v3.0 Measurable)

Read references/voiceprints/voice_fingerprint_engine.md. The v3.0 fingerprint upgrades voiceprints from descriptive docs into measurable authorial profiles.

Measured dimensions:

• Average sentence length and variance
• Compression ratio (words removed without meaning loss)
• Abstraction tolerance (% of sentences operating above concrete plane)
• Metaphor density (per 500 words)
• Question frequency
• Transition habits (top-5 transition words)
• Opening pattern repertoire
• Closing pattern repertoire
• Dominant syntactic structures
• Authority posture (warmth/dominance dial)

Available voiceprints (preserved): sovereign_commander, literary_recursive, sermon_black_church, investor_precision, founder_manifesto, academic_rigorous, casual_sharp, custom.

New in v3.0: courageous_builder.md — pattern for branded operator personas (Grace, founder assistants, ministry assistants, sales assistants, grant assistants, vertical bots).

8. Machine-Readable Schemas (11 Schemas)

v3.0's most important technical leap. Every pass output is also a JSON object.

Schemas live in schemas/. They unlock: CLI execution, MCP server execution, web app integration, CI writing checks, automated scoring, benchmark reports, issue templates, standard contribution tests, reproducible outputs, traceable quality improvement.

9. Rewrite Operators (24 in v3.0)

Preserved from v2.0 (19) + 5 new in v3.0:

10. File Reference Map (v3.0)

When this skill triggers, read files in this order based on task:

1. Always: This SKILL.md
2. Always: references/anti_patterns/phrases.md
3. Pass 0: references/compiler/intake_contract.md
4. Pass 2: references/compiler/corpus_governance.md
5. Pass 3: references/anti_patterns/structures.md + cadence.md + fake_depth.md
6. Pass 4 (general): references/compiler/architecture_graph.md
7. Pass 4 (persuasive): references/compiler/argument_graph.md
8. Pass 4 (narrative): references/compiler/scene_graph.md
9. Pass 5: references/compiler/epistemic_ledger.md
10. Pass 6: references/compiler/prose_compiler_v3.md + references/positive_patterns/paragraph_shapes.md
11. Pass 7: references/voiceprints/voice_fingerprint_engine.md + applicable voiceprint
12. Pass 8 (general): references/compiler/arena_delivery.md
13. Pass 8 (mixed genre): references/diagnostics/genre_collision_matrix.md
14. Pass 9: tests/adversarial_cases.md
15. Pass 10: references/diagnostics/scorecard.md
16. Pass 11: references/compiler/memory_system.md + benchmarks/runbook.md
17. Fiction: references/compiler/narrative_intelligence_engine.md + storyworld_memory.md + chapter_construction.md + character_role_archetypes.md
18. Thriller: above + references/genre_packs/thriller_scene_architecture.md + references/positive_patterns/tension_mechanics.md
19. Dialogue: references/genre_packs/dialogue.md
20. Grant / NOFO: references/genre_packs/grant_nofo.md + Pass 5 + Pass 8
21. Technical docs: references/genre_packs/technical_documentation.md
22. Journalism: references/genre_packs/journalism.md + Pass 5
23. Social media: references/genre_packs/social_media.md + Pass 8
24. YouTube script: references/genre_packs/youtube_script.md + Pass 8
25. Newsletter: references/genre_packs/newsletter.md
26. Resume / cover letter: references/genre_packs/resume_cover_letter.md
27. Real estate: references/genre_packs/real_estate.md
28. Loan officer: references/genre_packs/loan_officer.md + Pass 5
29. Church leadership: references/genre_packs/church_leadership.md + sermon.md
30. Small business operator: references/genre_packs/small_business_operator.md
31. Custom persona: references/voiceprints/courageous_builder.md
32. Schemas: schemas/*.schema.json for machine-readable execution
33. Agent execution: agents/agent_manifest.yaml + applicable agent docs
34. Benchmark: benchmarks/benchmark_manifest.yaml
35. Certification: certification/operator_levels.md

11. Output Modes (v3.0)

Default output is clean. Pass 0 contract may request any combination:

• clean — final draft, no markup
• annotated — draft with margin notes explaining decisions
• redline — original with tracked changes
• scorecard — full evaluation (human + JSON)
• violations — every rule triggered and how resolved
• next-pass — recommendations for further improvement
• scene-audit — chapter construction scorecard (narrative)
• `epistemic-ledger` (v3.0) — claim classification with source status
• `delivery-bundle` (v3.0) — packaged for target arena (memo / grant / social / YouTube / etc.)
• `voice-drift-report` (v3.0) — fingerprint baseline vs. current
• `benchmark-result` (v3.0) — regression vs. prior version

12. Epistemic Integrity Layer (v3.0 Hardened)

Every draft classifies sentences as: observed fact / sourced fact / inference / synthesis / recommendation / rhetoric.

Enforcement rules:

• Sourced facts require citations.
• Inferences must identify their premises.
• Recommendations must state the basis.
• Rhetoric must not masquerade as fact.
• Universal quantifiers (all, every, never, always) require evidence or qualification.
• Inflated verbs (revolutionize, transform, redefine) require concrete backing.
• No fabricated citations, statistics, quotes, or studies — ever.
• (v3.0) Every high-stakes domain (academic, medical, legal, government, grant, financial) MUST emit EpistemicLedgerV3.
• (v3.0) Source status flags: verified, user-provided, assumed, inferred, missing, unsafe. Any unsafe flag halts delivery.

13. Memory and Continuity (Longform)

For multi-chapter or multi-document projects, read references/compiler/memory_system.md and references/compiler/storyworld_memory.md. Track:

• Character voice continuity
• Thesis continuity
• Repeated metaphor detection
• Cross-section contradictions
• Emotional arc continuity
• Terminology lock (same concept = same word)
• Character role consistency (archetype doesn't shift without cause)
• Power object tracking across chapters
• Foreshadowing ledger (planted / paid off / orphaned)
• (v3.0) Storyworld canon hierarchy (canonical / sanctioned / fan-tier)
• (v3.0) Series escalation curve (does each book raise stakes or repeat?)
• (v3.0) Cross-book voice fingerprint stability

14. Benchmark Discipline

Read benchmarks/README.md, benchmark_manifest.yaml, runbook.md. v3.0 ships with 60 benchmark cases across 12 categories. A release cannot ship until it passes benchmark thresholds:

15. The v3.0 Vow

Writing Intelligence v1.0 proved AI-sounding writing could be defeated by compilation instead of cosmetic cleanup.

Writing Intelligence v2.0 proved fiction could be engineered as a living architecture.

Writing Intelligence v3.0 proves something larger:

Authorship can be governed without being flattened. Voice can be preserved while evidence is audited. Creativity can be systematized without becoming sterile. Language can be scored without becoming soulless. And writing can become infrastructure.

That is the category. That is the moat. That is the release.

Writing Intelligence v4.0 proves the next thing:

Governed writing can be made provable. Every claim can be pointed at. Every change can be refused. Every number on the screen can name its denominator — and where there is none, the honest answer is to say so rather than to print a number anyway.

v3 made writing governable. v4 makes governed writing checkable by someone who does not trust it.

— Antonio T. Smith Jr. / Density6 LLC