@@ -102,6 +102,7 @@ serde_yaml = "0.9"
 # Document conversion
 anydoc = "=0.2.4"
 pdf-inspector = { version = "1.17.0", default-features = false }
+roxmltree = { version = "0.21.1", default-features = false }
 
 # TypeScript binding generation (schema-first; gated by per-crate `ts` features)
 ts-rs = { version = "12", features = ["serde-json-impl", "no-serde-warnings"] }
 
@@ -35,7 +35,13 @@ agent-facing tool surface.
 - `document-read` owns offline byte-to-Markdown extraction. Non-PDF formats use
   anydoc; PDFs use its existing pdf-inspector backend's page API so readable
   pages survive alongside explicit OCR gaps. Keep source-page coverage separate
-  from Markdown line-window truncation. This dependency remains optional, with
+  from Markdown line-window truncation. `pages` selects original PDF pages,
+  PPTX slides, XLSX visible sheets, or explicitly synthetic text chunks for
+  reflowable/legacy formats. Office selection filters the in-memory OOXML
+  manifest while preserving package resources; never infer slides from headings
+  or claim that Word text chunks are printed pages. Keep normalized selections
+  in cache keys and apply line windows within the same selected representation.
+  Whole-source transfer and parser limits still apply. Dependencies remain optional, with
   OCR/network features disabled; workspace byte IO and model-facing guidance
   stay with their existing providers and Core tool owner.
 - Background exec-output and ExecCommand presentation helpers may own retained
 
@@ -6,7 +6,7 @@ edition.workspace = true
 [features]
 default = []
 shell-analysis = []
-document-read = ["dep:anydoc", "dep:pdf-inspector", "dep:sha2"]
+document-read = ["dep:anydoc", "dep:pdf-inspector", "dep:roxmltree", "dep:sha2", "dep:zip"]
 web-readable = ["dep:htmd", "dep:legible", "dep:readability-js"]
 
 [dependencies]
@@ -26,12 +26,14 @@ legible = { version = "0.4.2", optional = true }
 log = { workspace = true }
 pdf-inspector = { workspace = true, optional = true }
 regex = { workspace = true }
+roxmltree = { workspace = true, features = ["std", "positions"], optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 sha2 = { workspace = true, optional = true }
 tokio = { workspace = true, features = ["io-util", "rt", "sync", "time"] }
 tokio-util = { workspace = true, features = ["io-util"] }
 vte = { workspace = true, features = ["ansi"] }
+zip = { workspace = true, optional = true }
 
 [target.'cfg(windows)'.dependencies]
 windows = { workspace = true, features = [
 
@@ -1,5 +1,14 @@
 //! Document path recognition and optional provider-neutral Markdown conversion.
 
+mod selection;
+pub use selection::DocumentPageSelection;
+#[cfg(feature = "document-read")]
+mod office;
+#[cfg(feature = "document-read")]
+mod text_pages;
+#[cfg(feature = "document-read")]
+pub use text_pages::TEXT_CHUNK_CHARS;
+
 #[cfg(feature = "document-read")]
 use std::collections::VecDeque;
 #[cfg(feature = "document-read")]
@@ -39,6 +48,47 @@ pub struct ConvertedDocument {
     pub markdown: Arc<str>,
     pub source_format: &'static str,
     pub pdf_coverage: Option<PdfTextCoverage>,
+    pub pagination: DocumentPagination,
+}
+
+/// Selectable source units (or explicitly synthetic text chunks), not the returned line window.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DocumentPagination {
+    pub page_kind: &'static str,
+    pub page_count: usize,
+    pub selected_pages: String,
+    pub selected_page_count: usize,
+    pub next_page: Option<u32>,
+}
+
+#[cfg(feature = "document-read")]
+impl DocumentPagination {
+    fn new(
+        kind: &'static str,
+        count: usize,
+        selection: Option<&DocumentPageSelection>,
+    ) -> Result<Self, DocumentConversionError> {
+        let pages = selection
+            .map(|selection| selection.resolve(count))
+            .transpose()
+            .map_err(|error| DocumentConversionError::new("invalidPages", error))?;
+        let last = pages.as_ref().and_then(|pages| pages.last()).copied();
+        Ok(Self {
+            page_kind: kind,
+            page_count: count,
+            selected_pages: selection
+                .map(ToString::to_string)
+                .unwrap_or_else(|| match count {
+                    0 => String::new(),
+                    1 => "1".to_string(),
+                    _ => format!("1-{count}"),
+                }),
+            selected_page_count: pages.as_ref().map_or(count, Vec::len),
+            next_page: last
+                .filter(|last| (*last as usize) < count)
+                .and_then(|last| last.checked_add(1)),
+        })
+    }
 }
 
 /// Source-page coverage, independent of the line window returned from the extracted Markdown.
@@ -88,10 +138,11 @@ impl PdfTextCoverage {
 }
 
 #[cfg(feature = "document-read")]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 struct DocumentCacheKey {
     source_sha256: [u8; 32],
     format: Format,
+    selection: Option<DocumentPageSelection>,
 }
 
 #[cfg(feature = "document-read")]
@@ -109,8 +160,8 @@ struct DocumentCache {
 
 #[cfg(feature = "document-read")]
 impl DocumentCache {
-    fn get(&mut self, key: DocumentCacheKey) -> Option<ConvertedDocument> {
-        let index = self.entries.iter().position(|entry| entry.key == key)?;
+    fn get(&mut self, key: &DocumentCacheKey) -> Option<ConvertedDocument> {
+        let index = self.entries.iter().position(|entry| &entry.key == key)?;
         let entry = self.entries.remove(index)?;
         let document = entry.document.clone();
         self.entries.push_back(entry);
@@ -190,6 +241,16 @@ pub fn is_supported_document_path(path: &str) -> bool {
 pub async fn convert_document_to_markdown(
     bytes: Vec<u8>,
     path_hint: String,
+) -> Result<ConvertedDocument, DocumentConversionError> {
+    convert_document_pages_to_markdown(bytes, path_hint, None).await
+}
+
+/// Select document units before applying the caller's Markdown line window.
+#[cfg(feature = "document-read")]
+pub async fn convert_document_pages_to_markdown(
+    bytes: Vec<u8>,
+    path_hint: String,
+    selection: Option<DocumentPageSelection>,
 ) -> Result<ConvertedDocument, DocumentConversionError> {
     if bytes.len() > MAX_DOCUMENT_INPUT_BYTES {
         return Err(DocumentConversionError::new(
@@ -216,7 +277,7 @@ pub async fn convert_document_to_markdown(
         // Keep the permit inside the blocking task. If the async caller is cancelled, the parser
         // still occupies its bounded slot until the synchronous conversion actually exits.
         let _permit = permit;
-        convert_document_to_markdown_sync(&bytes, &path_hint)
+        convert_document_pages_to_markdown_sync(&bytes, &path_hint, selection.as_ref())
     })
     .await
     .map_err(|error| {
@@ -234,9 +295,10 @@ fn document_conversion_semaphore() -> &'static Arc<Semaphore> {
 }
 
 #[cfg(feature = "document-read")]
-fn convert_document_to_markdown_sync(
+fn convert_document_pages_to_markdown_sync(
     bytes: &[u8],
     path_hint: &str,
+    selection: Option<&DocumentPageSelection>,
 ) -> Result<ConvertedDocument, DocumentConversionError> {
     let format = Format::from_bytes(bytes)
         .or_else(|| Format::from_path(Path::new(path_hint)))
@@ -249,23 +311,35 @@ fn convert_document_to_markdown_sync(
     let cache_key = DocumentCacheKey {
         source_sha256: Sha256::digest(bytes).into(),
         format,
+        selection: selection.cloned(),
     };
     if let Some(document) = document_cache()
         .lock()
         .unwrap_or_else(|poisoned| poisoned.into_inner())
-        .get(cache_key)
+        .get(&cache_key)
     {
         return Ok(document);
     }
 
     let source_format = format_name(format);
-    let (markdown, pdf_coverage) = if format == Format::Pdf {
-        let (markdown, coverage) = extract_pdf_text(bytes)?;
-        (markdown, Some(coverage))
+    let (markdown, pdf_coverage, pagination) = if format == Format::Pdf {
+        let (markdown, coverage) = extract_pdf_text(bytes, selection)?;
+        let pagination = DocumentPagination::new("pdf_page", coverage.page_count, selection)?;
+        (markdown, Some(coverage), pagination)
+    } else if let Some(index) = office::OfficePageIndex::read(bytes, format)? {
+        let pagination = DocumentPagination::new(index.page_kind, index.page_count(), selection)?;
+        let selected_bytes = selection
+            .map(|selection| index.select(bytes, selection))
+            .transpose()?;
+        let markdown =
+            anydoc::to_markdown_bytes(selected_bytes.as_deref().unwrap_or(bytes), format)
+                .map_err(|error| DocumentConversionError::new(error.code(), error.to_string()))?;
+        (markdown, None, pagination)
     } else {
         let markdown = anydoc::to_markdown_bytes(bytes, format)
             .map_err(|error| DocumentConversionError::new(error.code(), error.to_string()))?;
-        (markdown, None)
+        let (markdown, pagination) = text_pages::select_text(markdown, selection)?;
+        (markdown, None, pagination)
     };
     if markdown.len() > MAX_DOCUMENT_MARKDOWN_BYTES {
         return Err(DocumentConversionError::new(
@@ -281,6 +355,7 @@ fn convert_document_to_markdown_sync(
         markdown: Arc::from(markdown),
         source_format,
         pdf_coverage,
+        pagination,
     };
     document_cache()
         .lock()
@@ -292,23 +367,42 @@ fn convert_document_to_markdown_sync(
 /// anydoc's PDF convenience API rejects the whole document when any page needs OCR.
 /// Use the same parser's page API to retain reliable text and explicitly mark gaps.
 #[cfg(feature = "document-read")]
-fn extract_pdf_text(bytes: &[u8]) -> Result<(String, PdfTextCoverage), DocumentConversionError> {
-    let extraction = pdf_inspector::extract_pages_markdown_mem(bytes, None).map_err(|error| {
+fn extract_pdf_text(
+    bytes: &[u8],
+    selection: Option<&DocumentPageSelection>,
+) -> Result<(String, PdfTextCoverage), DocumentConversionError> {
+    let map_error = |error: pdf_inspector::PdfError| {
         let code = match &error {
             pdf_inspector::PdfError::Encrypted => "encrypted",
             pdf_inspector::PdfError::Io(_) => "io",
             _ => "malformed",
         };
         DocumentConversionError::new(code, error.to_string())
-    })?;
+    };
+    // Validate against the parsed source page tree before passing zero-based indices to the
+    // backend, which otherwise returns an OCR placeholder for a nonexistent page.
+    let source_page_count = selection
+        .map(|_| {
+            pdf_inspector::classify_pdf_mem(bytes)
+                .map(|classification| classification.page_count as usize)
+                .map_err(map_error)
+        })
+        .transpose()?;
+    let selected_pages = selection
+        .map(|selection| selection.resolve(source_page_count.unwrap_or(0)))
+        .transpose()
+        .map_err(|error| DocumentConversionError::new("invalidPages", error))?
+        .map(|pages| pages.into_iter().map(|page| page - 1).collect::<Vec<_>>());
+    let extraction = pdf_inspector::extract_pages_markdown_mem(bytes, selected_pages.as_deref())
+        .map_err(map_error)?;
     if extraction.pages.is_empty() {
         return Err(DocumentConversionError::new(
             "malformed",
             "PDF contains no pages",
         ));
     }
     let mut coverage = PdfTextCoverage {
-        page_count: extraction.pages.len(),
+        page_count: source_page_count.unwrap_or(extraction.pages.len()),
         extracted_pages: Vec::new(),
         pages_needing_ocr: Vec::new(),
     };
@@ -364,6 +458,14 @@ fn format_name(format: Format) -> &'static str {
 mod tests {
     use super::*;
 
+    #[cfg(feature = "document-read")]
+    fn convert_document_to_markdown_sync(
+        bytes: &[u8],
+        path: &str,
+    ) -> Result<ConvertedDocument, DocumentConversionError> {
+        convert_document_pages_to_markdown_sync(bytes, path, None)
+    }
+
     #[test]
     fn pdf_gap_summary_is_bounded_without_losing_page_metadata() {
         let coverage = PdfTextCoverage {