@@ -351,19 +351,21 @@ version rather than depending on a mutable sibling checkout.
 
 ## Phase 5 — Additive semantic enrichment, complete F1 accounting, and unified diagnostics
 
-> **Status: IN PROGRESS (2026-08-27).** Begin with the neutral additive mapper,
-> the PolyglotSSSOM claim adapter, and an end-to-end BioProject/Study fixture using
-> the reviewed Phase 4 base mapping. Extend the same accounting model across all
-> supported F1 inputs after that boundary is stable.
+> **Status: COMPLETE (2026-08-27).** The neutral additive mapper, PolyglotSSSOM
+> claim adapter, and occurrence-level accounting now cover every supported F1
+> input without adding a parallel provenance artifact.
 >
 > **Implemented slices:** the shared diagnostic and field-accounting core, neutral
 > additive mapper, PolyglotSSSOM adapter, and artifact-qualified accounting for all
 > eight supported INSDC XML entities are implemented. Their tests resolve source
 > XML XPointers and emitted ArcIR JSON fragments, including the source-assertion
 > handoff to an additive base mapping, the connected BioSample-to-Experiment-to-Run
 > chain, analysis files and references, submission agents, and receipt
-> acknowledgements. Accounting for supplementary paper/count inputs is still
-> outstanding.
+> acknowledgements. Supplementary JATS front matter uses XPointer designations;
+> count-header cells use W3C Data Position Selectors over the exact immutable
+> bytes, so CSV, TSV, and materialized archive entries share one resolvable path.
+> Every emitted output is qualified against and resolved from a persisted ArcIR
+> state, and identical inputs produce deterministic reports and graph fragments.
 
 ### One result and diagnostic model
 
 
@@ -34,6 +34,7 @@
     <Compile Include="Ingest\Paper.fs" />
     <Compile Include="Ingest\CountData.fs" />
     <Compile Include="Ingest\Readers.fs" />
+    <Compile Include="Ingest\Accounting.fs" />
     <Compile Include="Ingest\Ingest.fs" />
     <None Include="..\..\docs\img\icon.png" Pack="true" PackagePath="" />
     <None Include="README.md" Pack="true" PackagePath="" />
 
@@ -10,7 +10,7 @@ open BioFSharp.ArcIR
 [<RequireQualifiedAccess>]
 module CountData =
 
-    let private fileId (file: ResourceFile) = "count:" + file.Name
+    let internal fileId (file: ResourceFile) = "count:" + file.Name
 
     /// Convert one count file into a `ConversionResult`: a `countMatrix` Resource node plus a `countColumn`
     /// fragment (with `hasColumn` and `producesData` edges) for each run-accession column in its header.
 
@@ -1,5 +1,6 @@
 namespace BioFSharp.INSDC.ArcIR
 
+open System.IO
 open BioFSharp.ArcIR
 
 /// The ingest facade: fold supplementary sources (a paper, a count-data archive) into ArcIR fragments and
@@ -17,10 +18,42 @@ module Ingest =
     /// Convert one already-read count file into fragments.
     let countData (countFile: CountFile) : ConversionResult = CountData.convert countFile
 
+    /// Convert and account for a JATS paper from its exact immutable artifact bytes.
+    let paperWithAccounting
+        (artifact: ArtifactRevision)
+        (fileName: string)
+        (bytes: byte array)
+        (relatedAccessions: string list)
+        : AccountedConversion =
+        IngestAccounting.paper artifact fileName bytes relatedAccessions
+
+    /// Convert and account for a delimited count table from its exact immutable artifact bytes.
+    let countDataWithAccounting
+        (artifact: ArtifactRevision)
+        (fileName: string)
+        (bytes: byte array)
+        : AccountedConversion =
+        IngestAccounting.countData artifact fileName bytes
+
     /// Read a paper from a JATS XML file and convert it, linking it to the given dataset accession(s).
     let paperFromJats (path: string) (relatedAccessions: string list) : ConversionResult =
         Paper.convert (IngestReaders.readJats path) (IngestReaders.describeFile path) relatedAccessions
 
+    /// Read a JATS paper, verify it against the declared artifact revision, convert it, and account for its front matter.
+    let paperFromJatsWithAccounting
+        (artifact: ArtifactRevision)
+        (path: string)
+        (relatedAccessions: string list)
+        : AccountedConversion =
+        paperWithAccounting artifact (Path.GetFileName path) (File.ReadAllBytes path) relatedAccessions
+
+    /// Read a count table, verify it against the declared artifact revision, convert it, and account for its header cells.
+    let countDataFromFileWithAccounting
+        (artifact: ArtifactRevision)
+        (path: string)
+        : AccountedConversion =
+        countDataWithAccounting artifact (Path.GetFileName path) (File.ReadAllBytes path)
+
     /// Read a count-data zip archive and convert each tabular entry into fragments.
     let countDataFromArchive (path: string) : ConversionResult list =
         IngestReaders.readCountArchive path |> CountData.convertMany
 
@@ -20,18 +20,18 @@ module Paper =
 
     /// The paper Resource node id: `doi:<doi>` when a DOI is present (stable across file copies), else
     /// `paper:<name>`.
-    let private paperId (meta: PaperMetadata) (file: ResourceFile) : string =
+    let internal paperId (meta: PaperMetadata) (file: ResourceFile) : string =
         match present meta.Doi with
         | Some doi -> "doi:" + doi.Trim().ToLowerInvariant()
         | None -> "paper:" + file.Name
 
     /// An author's dedup id: `agent:<email>`, else `agent:<orcid>`, else `agent:<name>`; `None` if all blank.
-    let private authorId (a: PaperAuthor) : string option =
+    let internal authorId (a: PaperAuthor) : string option =
         [ a.Email; a.Orcid; a.Name ]
         |> List.tryPick present
         |> Option.map (fun key -> "agent:" + key.Trim().ToLowerInvariant())
 
-    let private authorFragment (paperId: string) (a: PaperAuthor) : (ArcObject * ArcRelation) option =
+    let internal authorFragment (paperId: string) (a: PaperAuthor) : (ArcObject * ArcRelation) option =
         authorId a
         |> Option.map (fun authorNodeId ->
             let props =
 
@@ -4,6 +4,7 @@ open System
 open System.IO
 open System.IO.Compression
 open System.Security.Cryptography
+open System.Text
 open System.Text.RegularExpressions
 open System.Xml.Linq
 
@@ -37,6 +38,19 @@ module IngestReaders =
     let private countResourceFile (name: string) (byteSize: int64) : ResourceFile =
         { Name = name; ByteSize = Some byteSize; Checksum = None; MediaType = mediaType name }
 
+    let private sha256 (bytes: byte array) =
+        use sha = SHA256.Create()
+        "sha256:" + (BitConverter.ToString(sha.ComputeHash bytes).Replace("-", "").ToLowerInvariant())
+
+    let internal describeBytes (name: string) (bytes: byte array) : ResourceFile =
+        if isNull bytes then
+            nullArg (nameof bytes)
+
+        { Name = name
+          ByteSize = Some(int64 bytes.LongLength)
+          Checksum = Some(sha256 bytes)
+          MediaType = mediaType name }
+
     // ---- files ----
 
     /// Describe a file as a `ResourceFile`: name, byte size, a `sha256:<hex>` checksum, and a media type
@@ -67,11 +81,8 @@ module IngestReaders =
         | s when String.IsNullOrWhiteSpace s -> None
         | s -> Some(s.Trim())
 
-    /// Read paper-level metadata from a JATS XML article: title, DOI, journal, and the authors
-    /// (name, email, affiliation, ORCID). Elements are matched by local name, so namespaced and
-    /// non-namespaced JATS both work.
-    let readJats (path: string) : PaperMetadata =
-        let root = XDocument.Load(path: string).Root
+    let private readJatsDocument (document: XDocument) : PaperMetadata =
+        let root = document.Root
         let descendants (name: string) = root.Descendants() |> Seq.filter (fun e -> e.Name.LocalName = name)
         let firstText name = descendants name |> Seq.tryHead |> Option.bind (fun e -> text e.Value)
 
@@ -116,6 +127,19 @@ module IngestReaders =
 
         { Title = firstText "article-title"; Doi = doi; Journal = firstText "journal-title"; Authors = authors }
 
+    let internal readJatsBytes (bytes: byte array) : PaperMetadata =
+        if isNull bytes then
+            nullArg (nameof bytes)
+
+        use stream = new MemoryStream(bytes, false)
+        XDocument.Load stream |> readJatsDocument
+
+    /// Read paper-level metadata from a JATS XML article: title, DOI, journal, and the authors
+    /// (name, email, affiliation, ORCID). Elements are matched by local name, so namespaced and
+    /// non-namespaced JATS both work.
+    let readJats (path: string) : PaperMetadata =
+        XDocument.Load(path: string) |> readJatsDocument
+
     // ---- count data ----
 
     /// Parse a count-matrix header line into its run-accession columns, each with its 1-based position
@@ -131,6 +155,20 @@ module IngestReaders =
             |> Array.choose (fun (index, cell) -> if runAccession.IsMatch cell then Some { Index = index; RunAccession = cell } else None)
             |> List.ofArray
 
+    let internal readCountBytes (name: string) (bytes: byte array) : CountFile =
+        if isNull bytes then
+            nullArg (nameof bytes)
+
+        use stream = new MemoryStream(bytes, false)
+        use reader = new StreamReader(stream, Encoding.UTF8, true)
+
+        let header =
+            match reader.ReadLine() with
+            | null -> ""
+            | line -> line
+
+        { File = countResourceFile name (int64 bytes.LongLength); Columns = parseHeader header }
+
     /// Read one loose count file: its metadata plus the run-accession columns parsed from its header.
     let readCountFile (path: string) : CountFile =
         let info = FileInfo path
 
@@ -19,8 +19,11 @@ Run, Analysis, Submission, and Receipt, plus supplementary papers and count data
 
 The graph can be rendered as text, GraphML, or a self-contained HTML page. These
 are derived inspection tools; the embedded HTML page is not the intended final
-workbench architecture. Deterministic canonical persistence and revision-bound
-fragment addressing are planned separately.
+workbench architecture. `*WithAccounting` F1 functions bind exact source
+occurrences to typed locations in the resulting graph: INSDC and JATS XML use
+XPointer, while count-header cells use W3C byte-position selectors. The source
+artifact bytes are digest-checked, and emitted locations can be qualified against
+the canonical persisted ArcIR state with `FieldAccounting.qualifyEmitted`.
 
 Built on
 [`BioFSharp.IO.INSDC`](https://www.nuget.org/packages/BioFSharp.IO.INSDC).
 
@@ -405,3 +405,116 @@ type F1AccountingTests() =
 
             find "/RECEIPT/ACTIONS[1]" accountedReceipt.Accounting
             |> expectUnsupported accountedReceipt.Accounting)
+
+    [<Fact>]
+    member _.``JATS front matter accounting resolves source and ArcIR output designations`` () =
+        let path = TestFiles.fixture "paper-PRJDB5192.jats.xml"
+        let bytes = File.ReadAllBytes path
+        let xml = Encoding.UTF8.GetString bytes
+        let revision = ArtifactRevision.ofBytes path None bytes
+        let accounted = Ingest.paperWithAccounting revision (Path.GetFileName path) bytes []
+        let repeated = Ingest.paperWithAccounting revision (Path.GetFileName path) bytes []
+        let graph = INSDC.build [ accounted.Conversion ]
+        let sourceDocument = XPointer.entityDoc xml
+        let outputLocations = ArcIRJson.locations graph |> Set.ofSeq
+
+        Assert.Equal(accounted, repeated)
+        Assert.NotEmpty accounted.Accounting.Entries
+        Assert.Empty accounted.Accounting.Diagnostics.Diagnostics
+
+        for entry in accounted.Accounting.Entries do
+            Assert.Equal(revision, entry.Input.Artifact)
+            Assert.Equal(F1Accounting.XPointerConformsTo, entry.Input.Selector.ConformsTo)
+            Assert.True(
+                XPointer.resolve sourceDocument entry.Input.Selector.Value |> Option.isSome,
+                $"JATS selector did not resolve: {entry.Input.Selector.Value}"
+            )
+
+            match entry.Outcome with
+            | FieldAccountingOutcome.Emitted outputs ->
+                Assert.NotEmpty outputs
+                for output in outputs do
+                    Assert.Contains(output, outputLocations)
+            | FieldAccountingOutcome.Ignored reason -> Assert.False(String.IsNullOrWhiteSpace reason)
+            | outcome -> failwithf "Expected emitted or reviewed-ignored JATS metadata, got %A" outcome
+
+        withTempDirectory (fun directory ->
+            assertQualifiedOutputsResolve directory "paper-state.arcir.json" graph accounted.Accounting
+            |> ignore)
+
+        let title =
+            accounted.Accounting.Entries
+            |> List.find (fun entry -> entry.Input.Selector.Value.Contains("article-title"))
+
+        match title.Outcome with
+        | FieldAccountingOutcome.Emitted outputs ->
+            Assert.True(outputs |> List.exists (function ArcJsonLocation.ObjectAnnotationValue _ -> true | _ -> false))
+        | outcome -> failwithf "Expected the JATS title to be emitted, got %A" outcome
+
+    [<Fact>]
+    member _.``count header accounting uses byte-position cells and resolves every ArcIR output`` () =
+        let path = TestFiles.fixture "counts-PRJDB5192.tsv"
+        let bytes = File.ReadAllBytes path
+        let revision = ArtifactRevision.ofBytes path None bytes
+        let accounted = Ingest.countDataWithAccounting revision (Path.GetFileName path) bytes
+        let repeated = Ingest.countDataWithAccounting revision (Path.GetFileName path) bytes
+        let graph = INSDC.build [ accounted.Conversion ]
+        let outputLocations = ArcIRJson.locations graph |> Set.ofSeq
+        let selectorPattern =
+            "^#selector\\(type=DataPositionSelector,start=(\\d+),end=(\\d+)\\)$"
+
+        let selectedValue (entry: FieldAccountingEntry) =
+            let matched =
+                Text.RegularExpressions.Regex.Match(entry.Input.Selector.Value, selectorPattern)
+
+            Assert.True(matched.Success, $"Invalid data-position selector: {entry.Input.Selector.Value}")
+            let startPosition = Int32.Parse matched.Groups.[1].Value
+            let endPosition = Int32.Parse matched.Groups.[2].Value
+            Assert.InRange(startPosition, 0, bytes.Length)
+            Assert.InRange(endPosition, startPosition, bytes.Length)
+            Encoding.UTF8.GetString(bytes, startPosition, endPosition - startPosition)
+
+        Assert.Equal(accounted, repeated)
+        Assert.Equal(3, accounted.Accounting.Entries.Length)
+        Assert.Empty accounted.Accounting.Diagnostics.Diagnostics
+
+        for entry in accounted.Accounting.Entries do
+            Assert.Equal(revision, entry.Input.Artifact)
+            Assert.Equal(IngestAccounting.DataPositionSelectorConformsTo, entry.Input.Selector.ConformsTo)
+            Assert.False(String.IsNullOrWhiteSpace(selectedValue entry))
+
+            match entry.Outcome with
+            | FieldAccountingOutcome.Emitted outputs ->
+                Assert.NotEmpty outputs
+                for output in outputs do
+                    Assert.Contains(output, outputLocations)
+            | FieldAccountingOutcome.Ignored reason -> Assert.False(String.IsNullOrWhiteSpace reason)
+            | outcome -> failwithf "Expected emitted or reviewed-ignored count header cell, got %A" outcome
+
+        let featureColumn =
+            accounted.Accounting.Entries
+            |> List.find (fun entry -> selectedValue entry = "gene_id")
+
+        match featureColumn.Outcome with
+        | FieldAccountingOutcome.Ignored _ -> ()
+        | outcome -> failwithf "Expected the feature identifier column to be intentionally ignored, got %A" outcome
+
+        let runColumn =
+            accounted.Accounting.Entries
+            |> List.find (fun entry -> selectedValue entry = "DRR072834")
+
+        match runColumn.Outcome with
+        | FieldAccountingOutcome.Emitted outputs ->
+            Assert.True(outputs |> List.exists (function ArcJsonLocation.Relation _ -> true | _ -> false))
+        | outcome -> failwithf "Expected the run header to emit the column and linkage, got %A" outcome
+
+        withTempDirectory (fun directory ->
+            assertQualifiedOutputsResolve directory "count-state.arcir.json" graph accounted.Accounting
+            |> ignore)
+
+        let mismatched = Array.copy bytes
+        mismatched.[0] <- mismatched.[0] ^^^ 1uy
+
+        Assert.Throws<ArgumentException>(fun () ->
+            Ingest.countDataWithAccounting revision (Path.GetFileName path) mismatched |> ignore)
+        |> ignore