Frontend: zip + multi-file uploads, progress with stage labels, chunk detail tab

- Upload widget now accepts .zip and multiple files (gr.File with
file_count='multiple'). Server-side _extract_uploads_to_parse(...)
unzips one level, filters by extension, applies path-traversal guard,
caps at MAX_BATCH_DOCS (default 20) so a malicious zip can't fan out.
Per-file MAX_UPLOAD_BYTES / MAX_PAGE_COUNT guards still apply.
- For batch input, summary.batch lists every parsed doc with its
headline metrics + an aggregate block (total_chunks, mean_quality_score,
etc.). The Markdown tab still shows the first doc; full set is in the
artifact zip.
- gr.Progress callback wired into parse_uploaded_document with stage
labels: 'Validating uploads', 'Parsing N/M: <name>', 'Bundling
artifacts', 'Done'. Per-doc progress derived from list position.
- New 'Chunks' tab with a richer payload:
- Total / parent / child / table-linked / figure-linked / visual-context counts.
- Per-strategy block: count, token_count_min/median/max, 3 sample
chunks with previews truncated to 240 chars.
- The legacy chunking plan (strategy ladder + reasons) is nested at
chunking_payload.plan.
- UI top-level instructions explain the upload modes and per-file caps.

4 new tests cover: zip extraction with two markdown docs (assert batch
metadata + aggregate), multi-file list upload, mixed-content zip
(.exe filtered out, .md preserved), and chunk-detail payload shape.

Test count: 254/254.

app.py

@@ -5,8 +5,9 @@ from __future__ import annotations
 import os
 import shutil
 import tempfile
+import zipfile
 from pathlib import Path
-from typing import Any
+from typing import Any, Iterable
 
 try:
     import gradio as gr
@@ -45,6 +46,12 @@ LIVE_GPU_CONFIG = ROOT / "configs" / "live_gpu_repair.yaml"
 # Spaces or tighten further for public ones.
 MAX_UPLOAD_BYTES = int(os.environ.get("ZSGDP_MAX_UPLOAD_BYTES", str(50 * 1024 * 1024)))  # 50 MB
 MAX_PAGE_COUNT = int(os.environ.get("ZSGDP_MAX_PAGE_COUNT", "200"))
+# Cap on docs extracted from a single zip so a malicious archive can't
+# fan out into thousands of parses. Each doc still goes through the
+# per-file MAX_UPLOAD_BYTES / MAX_PAGE_COUNT guards.
+MAX_BATCH_DOCS = int(os.environ.get("ZSGDP_MAX_BATCH_DOCS", "20"))
+
+SUPPORTED_PARSE_EXTS = (".pdf", ".md", ".txt", ".html", ".htm")
 
 
 class UploadRejected(Exception):
@@ -128,57 +135,288 @@ def _empty_outputs(reason: str, source: Path | None, *, rejected: bool, runtime:
     return ("", summary, {}, {}, {}, runtime, [], {}, {}, None, [])
 
 
-def parse_uploaded_document(file_obj: Any, pipeline_mode: str):
-    """Parse a document into Markdown, structured JSON, and retrieval-ready chunks.
+def _build_chunk_detail(parsed) -> dict[str, Any]:
+    """Produce a richer chunking summary than the bare chunking_plan.
+
+    Surfaces strategy counts, token-count distribution, sample chunks per
+    strategy (truncated to keep the payload UI-friendly), and counts of
+    tables / figures / parent / child chunks. Companion to the
+    `chunking_plan` JSON which only describes the strategy ladder.
+    """
+
+    chunks = parsed.chunks
+    by_strategy: dict[str, list] = {}
+    for chunk in chunks:
+        by_strategy.setdefault(chunk.strategy, []).append(chunk)
+
+    strategy_breakdown: dict[str, dict[str, Any]] = {}
+    for strategy, items in sorted(by_strategy.items()):
+        token_counts = sorted(item.token_count for item in items)
+        sample_chunks = []
+        for item in items[:3]:
+            preview = item.text.strip()
+            if len(preview) > 240:
+                preview = preview[:237] + "..."
+            sample_chunks.append(
+                {
+                    "chunk_id": item.chunk_id,
+                    "page_start": item.page_start,
+                    "page_end": item.page_end,
+                    "section_path": item.section_path,
+                    "boundary_reason": item.boundary_reason,
+                    "token_count": item.token_count,
+                    "source_parser": item.source_parser,
+                    "preview": preview,
+                }
+            )
+        strategy_breakdown[strategy] = {
+            "count": len(items),
+            "token_count_min": token_counts[0] if token_counts else 0,
+            "token_count_median": token_counts[len(token_counts) // 2] if token_counts else 0,
+            "token_count_max": token_counts[-1] if token_counts else 0,
+            "samples": sample_chunks,
+        }
+
+    parent_count = sum(1 for c in chunks if c.content_type == "parent")
+    child_count = sum(1 for c in chunks if c.parent_chunk_id)
+    table_chunks = sum(1 for c in chunks if c.table_ids)
+    figure_chunks = sum(1 for c in chunks if c.figure_ids)
+    visual_context = sum(1 for c in chunks if c.requires_visual_context)
+
+    return {
+        "total_chunks": len(chunks),
+        "parent_chunks": parent_count,
+        "child_chunks": child_count,
+        "table_linked_chunks": table_chunks,
+        "figure_linked_chunks": figure_chunks,
+        "visual_context_required": visual_context,
+        "strategies": strategy_breakdown,
+        "plan": parsed.provenance.get("chunking", {}),
+    }
+
+
+def _extract_uploads_to_parse(uploads: Iterable[Path], work_dir: Path) -> list[Path]:
+    """Resolve a set of uploaded files (possibly zips) into individual docs.
+
+    Each input is either:
+    - A supported document file (.pdf, .md, .txt, .html) — kept as-is.
+    - A .zip archive — extracted; supported files inside are added to the
+      list. Nested zips are skipped (no recursive extraction; one level only).
+    Other extensions are silently dropped.
+
+    The total number of resolved docs is capped at MAX_BATCH_DOCS to bound
+    the worst-case parse time per request.
+    """
+
+    resolved: list[Path] = []
+    for upload in uploads:
+        ext = upload.suffix.lower()
+        if ext == ".zip":
+            extract_dir = Path(tempfile.mkdtemp(prefix="zsgdp_zip_", dir=work_dir))
+            try:
+                with zipfile.ZipFile(upload) as zf:
+                    # Skip directories and nested zips.
+                    for member in zf.namelist():
+                        if member.endswith("/"):
+                            continue
+                        member_lower = member.lower()
+                        if not member_lower.endswith(SUPPORTED_PARSE_EXTS):
+                            continue
+                        if "__MACOSX" in member or member_lower.startswith("."):
+                            continue
+                        # Path traversal guard.
+                        target = (extract_dir / member).resolve()
+                        if not str(target).startswith(str(extract_dir.resolve())):
+                            continue
+                        target.parent.mkdir(parents=True, exist_ok=True)
+                        with zf.open(member) as source, open(target, "wb") as out:
+                            shutil.copyfileobj(source, out)
+                        resolved.append(target)
+            except zipfile.BadZipFile:
+                _logger.warning("space_zip_corrupt", extra={"path": str(upload)})
+                continue
+        elif ext in SUPPORTED_PARSE_EXTS:
+            resolved.append(upload)
+        else:
+            _logger.info("space_upload_skipped", extra={"path": str(upload), "reason": "unsupported_extension"})
+
+        if len(resolved) >= MAX_BATCH_DOCS:
+            break
+
+    return resolved[:MAX_BATCH_DOCS]
+
+
+def _parse_one_doc(
+    source: Path,
+    output_dir: Path,
+    pipeline_mode: str,
+) -> dict[str, Any]:
+    """Parse a single doc and return a per-doc result block.
+
+    Raises on parse failure so the batch driver can record the error and
+    continue with remaining docs instead of aborting the whole request.
+    """
+
+    config_path = _config_path_for_mode(pipeline_mode)
+    parsed = parse_document(source, output_dir, config_path=config_path)
+    artifact_validation = validate_artifact_manifest(output_dir)
+    individual_files = _collect_artifact_files(output_dir)
+    return {
+        "source_path": str(source),
+        "doc_id": parsed.doc_id,
+        "file_type": parsed.file_type,
+        "elements": len(parsed.elements),
+        "tables": len(parsed.tables),
+        "figures": len(parsed.figures),
+        "chunks": len(parsed.chunks),
+        "quality_score": parsed.quality_report.score,
+        "blocking": parsed.quality_report.has_blocking_failures,
+        "artifact_manifest_valid": artifact_validation.get("valid"),
+        "individual_artifact_count": len(individual_files),
+        "_parsed": parsed,
+        "_artifact_validation": artifact_validation,
+        "_individual_files": individual_files,
+        "_output_dir": str(output_dir),
+    }
+
+
+def parse_uploaded_document(file_obj: Any, pipeline_mode: str, progress: Any = None):
+    """Parse one or more documents into Markdown, structured JSON, and chunks.
+
+    Accepts either a single file or a list of files (Gradio's `file_count="multiple"`
+    semantics). `.zip` uploads are extracted on the server side and each
+    supported file inside is parsed; total docs are capped at
+    MAX_BATCH_DOCS (default 20) to bound the worst-case work per request.
 
-    Use when a user supplies a document (PDF, Markdown, plaintext, HTML) and
-    wants either (a) the text reconstructed cleanly, (b) structured elements
-    + tables + figures with bounding boxes, (c) chunks for downstream RAG, or
-    (d) an audit trail showing which parsers ran and how the merger resolved
-    conflicts. Output bundles include SHA-256-checksummed artifact manifests.
+    For multi-doc inputs the Markdown tab shows the first document's
+    output; the Summary tab includes a `batch` block listing every doc's
+    headline metrics; the Artifacts zip contains every per-doc directory.
+
+    Use when a user supplies one or many documents and wants either
+    (a) the text reconstructed cleanly, (b) structured elements + tables
+    + figures with bounding boxes, (c) chunks for downstream RAG, or
+    (d) an audit trail showing which parsers ran and how the merger
+    resolved conflicts.
 
     Args:
-        file_obj: Uploaded document. Max 50 MB and 200 pages by default
-            (configurable per Space via ZSGDP_MAX_UPLOAD_BYTES /
-            ZSGDP_MAX_PAGE_COUNT). Oversized uploads are rejected with a
-            clear UI error before parsing starts.
-        pipeline_mode: "Docling + PyMuPDF" runs Docling primary with PyMuPDF
-            for the parser-disagreement signal; "Default lightweight" uses
-            text + PyMuPDF only.
-
-    Returns an 11-tuple matching the Gradio outputs: canonical markdown,
-    summary JSON, quality report, parser metrics, chunking plan, GPU runtime
-    status, planned GPU tasks, GPU task preflight report, artifact manifest
-    validation, archive zip path, individual artifact file list.
+        file_obj: Uploaded file(s). Single `.pdf` / `.md` / `.txt` /
+            `.html`, or a `.zip` of those, or a list of any of the above.
+            Per-file caps of 50 MB and 200 pages apply (configurable via
+            ZSGDP_MAX_UPLOAD_BYTES / ZSGDP_MAX_PAGE_COUNT).
+        pipeline_mode: "Docling + PyMuPDF" / "Default lightweight" /
+            "Live GPU repair". The third dispatches malformed-table,
+            OCR-coverage, figure, and reading-order issues to the
+            configured GPU backend (Qwen2.5-VL by default).
+        progress: optional Gradio Progress object (auto-injected by the
+            Gradio click handler — leave None for direct API calls).
     """
 
+    if progress is None:
+        # When called via /gradio_api/call, no progress is wired; use a no-op
+        # so the function signature stays consistent.
+        def progress(value, *, desc=""):  # type: ignore[no-redef]
+            return None
+
     if file_obj is None:
         return _empty_outputs("Upload a document first.", None, rejected=False, runtime={})
 
-    source = Path(file_obj.name)
+    progress(0.0, desc="Validating uploads...")
+
+    # Normalise to a list of Path. Gradio passes a single FileData when
+    # file_count='single' and a list when 'multiple'.
+    if isinstance(file_obj, list):
+        upload_paths = [Path(item.name if hasattr(item, "name") else item) for item in file_obj if item is not None]
+    elif hasattr(file_obj, "name"):
+        upload_paths = [Path(file_obj.name)]
+    else:
+        upload_paths = [Path(str(file_obj))]
+    if not upload_paths:
+        return _empty_outputs("Upload a document first.", None, rejected=False, runtime={})
+
     work_dir = Path(tempfile.mkdtemp(prefix="zeroshotgpu_"))
-    output_dir = work_dir / "parsed"
-    config_path = _config_path_for_mode(pipeline_mode)
+    docs_to_parse = _extract_uploads_to_parse(upload_paths, work_dir)
 
-    try:
-        _validate_upload(source)
-    except UploadRejected as exc:
-        _logger.warning(
-            "space_upload_rejected",
-            extra={"source_path": str(source), "reason": str(exc)},
-        )
+    if not docs_to_parse:
         runtime = runtime_status_for_mode(pipeline_mode)
-        return _empty_outputs(str(exc), source, rejected=True, runtime=runtime)
+        return _empty_outputs(
+            "No supported documents found in the upload (accepted: pdf/md/txt/html, optionally inside a zip).",
+            upload_paths[0],
+            rejected=True,
+            runtime=runtime,
+        )
 
-    try:
-        parsed = parse_document(source, output_dir, config_path=config_path)
-    except Exception as exc:  # pragma: no cover - surfaced in the Space UI.
+    # Per-file abuse guard.
+    for doc in docs_to_parse:
+        try:
+            _validate_upload(doc)
+        except UploadRejected as exc:
+            _logger.warning(
+                "space_upload_rejected",
+                extra={"source_path": str(doc), "reason": str(exc)},
+            )
+            runtime = runtime_status_for_mode(pipeline_mode)
+            return _empty_outputs(str(exc), doc, rejected=True, runtime=runtime)
+
+    progress(0.05, desc=f"Parsing {len(docs_to_parse)} document(s)...")
+
+    output_root = work_dir / "parsed"
+    output_root.mkdir(parents=True, exist_ok=True)
+    per_doc_results: list[dict[str, Any]] = []
+    used_names: set[str] = set()
+
+    for index, doc in enumerate(docs_to_parse, start=1):
+        # Stable per-doc subdir.
+        stem = doc.stem or f"doc_{index}"
+        candidate = stem
+        suffix = 2
+        while candidate in used_names:
+            candidate = f"{stem}_{suffix}"
+            suffix += 1
+        used_names.add(candidate)
+        doc_out = output_root / candidate
+
+        progress(
+            0.05 + 0.85 * (index - 1) / max(1, len(docs_to_parse)),
+            desc=f"Parsing {index}/{len(docs_to_parse)}: {doc.name}",
+        )
+        try:
+            result = _parse_one_doc(doc, doc_out, pipeline_mode)
+            per_doc_results.append(result)
+        except Exception as exc:  # pragma: no cover - surfaced in UI
+            _logger.warning(
+                "space_parse_failed",
+                extra={"source_path": str(doc), "error": str(exc)},
+            )
+            per_doc_results.append(
+                {
+                    "source_path": str(doc),
+                    "error": str(exc),
+                    "doc_id": None,
+                    "_parsed": None,
+                }
+            )
+
+    progress(0.92, desc="Bundling artifacts...")
+
+    # Pick the first successful parse as the primary doc shown in the UI.
+    successful = [r for r in per_doc_results if r.get("_parsed") is not None]
+    if not successful:
         runtime = runtime_status_for_mode(pipeline_mode)
-        return _empty_outputs(str(exc), source, rejected=False, runtime=runtime)
+        first_error = next((r.get("error") for r in per_doc_results if r.get("error")), "All parses failed.")
+        return _empty_outputs(first_error, upload_paths[0], rejected=False, runtime=runtime)
+
+    primary = successful[0]
+    parsed = primary["_parsed"]
+    artifact_validation = primary["_artifact_validation"]
+    individual_files = primary["_individual_files"]
+
+    # If batch, the archive bundles the whole output_root; otherwise just the
+    # single doc's dir. Always returns a single zip path.
+    if len(per_doc_results) > 1:
+        archive_path = shutil.make_archive(str(output_root), "zip", output_root)
+    else:
+        archive_path = shutil.make_archive(str(Path(primary["_output_dir"])), "zip", primary["_output_dir"])
 
-    artifact_validation = validate_artifact_manifest(output_dir)
-    archive_path = shutil.make_archive(str(output_dir), "zip", output_dir)
-    individual_files = _collect_artifact_files(output_dir)
     runtime = parsed.provenance.get("gpu_runtime", {})
     summary = {
         "doc_id": parsed.doc_id,
@@ -197,12 +435,41 @@ def parse_uploaded_document(file_obj: Any, pipeline_mode: str):
         "artifact_checked_count": artifact_validation.get("checked_count"),
         "individual_artifact_count": len(individual_files),
     }
+
+    if len(per_doc_results) > 1:
+        successful_count = sum(1 for r in per_doc_results if r.get("_parsed") is not None)
+        summary["batch"] = {
+            "input_count": len(docs_to_parse),
+            "successful_count": successful_count,
+            "failed_count": len(per_doc_results) - successful_count,
+            "documents": [
+                {key: value for key, value in record.items() if not key.startswith("_")}
+                for record in per_doc_results
+            ],
+            "aggregate": {
+                "total_elements": sum(r.get("elements", 0) for r in per_doc_results if r.get("elements") is not None),
+                "total_tables": sum(r.get("tables", 0) for r in per_doc_results if r.get("tables") is not None),
+                "total_figures": sum(r.get("figures", 0) for r in per_doc_results if r.get("figures") is not None),
+                "total_chunks": sum(r.get("chunks", 0) for r in per_doc_results if r.get("chunks") is not None),
+                "mean_quality_score": (
+                    sum(r.get("quality_score", 0.0) for r in per_doc_results if r.get("quality_score") is not None)
+                    / max(1, successful_count)
+                ),
+            },
+        }
+
+    chunking_payload = {
+        "plan": parsed.provenance.get("chunking", {}),
+        "detail": _build_chunk_detail(parsed),
+    }
+    progress(1.0, desc="Done")
+
     return (
         parsed.to_markdown(),
         summary,
         parsed.quality_report.to_dict(),
         parsed.provenance.get("parser_metrics", {}),
-        parsed.provenance.get("chunking", {}),
+        chunking_payload,
         runtime,
         parsed.provenance.get("gpu_tasks", []),
         parsed.provenance.get("gpu_task_report", {}),
@@ -296,27 +563,63 @@ def run_benchmark_in_space() -> dict:
 
 
 with gr.Blocks(title="zeroshotGPU") as demo:
-    gr.Markdown("# zeroshotGPU")
+    gr.Markdown(
+        "# zeroshotGPU\n\n"
+        "Self-hosted agentic document parser. Upload a single document, multiple "
+        "documents, or a `.zip` of documents (PDF / Markdown / plaintext / HTML). "
+        "Each parse emits canonical markdown, structured JSON, retrieval-ready "
+        "chunks (multi-strategy), a quality report with GT-comparison metrics "
+        "where applicable, and a SHA-256-checksummed artifact manifest. "
+        f"Per-file caps: {MAX_UPLOAD_BYTES // (1024 * 1024)} MB / "
+        f"{MAX_PAGE_COUNT} pages. Batch cap: {MAX_BATCH_DOCS} docs per request."
+    )
     with gr.Row():
-        upload = gr.File(label="Document", file_types=[".pdf", ".md", ".txt", ".html"])
+        upload = gr.File(
+            label="Document(s) — single file, multi-select, or .zip",
+            file_types=[".pdf", ".md", ".txt", ".html", ".htm", ".zip"],
+            file_count="multiple",
+        )
         with gr.Column():
             pipeline = gr.Dropdown(
                 choices=["Docling + PyMuPDF", "Default lightweight", "Live GPU repair"],
                 value="Docling + PyMuPDF",
                 label="Pipeline",
-                info="`Live GPU repair` enables repair.execute_gpu_escalations=true and dispatches malformed-table / OCR / figure / reading-order issues to Qwen2.5-VL on the configured GPU backend.",
+                info="`Docling + PyMuPDF` runs both for the disagreement signal. `Default lightweight` is text + PyMuPDF only. `Live GPU repair` enables repair.execute_gpu_escalations=true and dispatches malformed-table / OCR / figure / reading-order issues to Qwen2.5-VL.",
             )
             parse_button = gr.Button("Parse", variant="primary")
             archive = gr.File(label="Artifacts (zip)")
     with gr.Tabs():
         with gr.Tab("Markdown"):
+            gr.Markdown(
+                "_Canonical markdown reconstruction of the parsed document. "
+                "For batch uploads, this shows the first document; the full "
+                "set is in the artifacts zip._"
+            )
             markdown = gr.Markdown(label="Canonical Markdown")
         with gr.Tab("Run"):
+            gr.Markdown(
+                "_Summary, quality report, parser metrics, and artifact "
+                "validation. For batch uploads, `Summary.batch` lists every "
+                "document parsed in the request._"
+            )
             summary = gr.JSON(label="Summary")
             quality = gr.JSON(label="Quality Report")
             parser_metrics = gr.JSON(label="Parser Metrics")
-            chunking = gr.JSON(label="Chunking Plan")
             artifact_validation = gr.JSON(label="Artifact Manifest Validation")
+        with gr.Tab("Chunks"):
+            gr.Markdown(
+                "_Per-strategy chunk breakdown: counts, token-count "
+                "distribution (min / median / max), and three sample chunks "
+                "with previews per strategy. The full chunks.jsonl is in the "
+                "Artifacts tab and inside the zip._\n\n"
+                "Strategies emitted by default: `fixed_token_baseline`, "
+                "`recursive_structure`, `parent_child` (with linked parent / "
+                "child IDs), `page_level`, plus `table` / `figure` chunks "
+                "with provenance. `semantic`, `late`, `vision_guided`, and "
+                "`agentic_proposition` are config-gated stubs that emit "
+                "deterministic candidates marked for backend replacement."
+            )
+            chunking = gr.JSON(label="Chunking plan + per-strategy detail")
         with gr.Tab("Artifacts"):
             gr.Markdown(
                 "Each top-level artifact is downloadable individually. "

tests/test_app.py

@@ -137,5 +137,122 @@ class UploadGuardTests(unittest.TestCase):
         self.assertNotIn("rejected", summary)
 
 
+class BatchAndZipUploadTests(unittest.TestCase):
+    def test_zip_upload_extracts_and_parses_each_doc(self):
+        if space_app is None:
+            self.skipTest(APP_IMPORT_ERROR)
+
+        import zipfile
+
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            # Build a small zip with two markdown docs.
+            doc_a = tmp_path / "a.md"
+            doc_a.write_text("# Doc A\n\nFirst.\n", encoding="utf-8")
+            doc_b = tmp_path / "b.md"
+            doc_b.write_text("# Doc B\n\nSecond.\n", encoding="utf-8")
+            zip_path = tmp_path / "batch.zip"
+            with zipfile.ZipFile(zip_path, "w") as zf:
+                zf.write(doc_a, arcname="a.md")
+                zf.write(doc_b, arcname="b.md")
+
+            outputs = space_app.parse_uploaded_document(
+                _UploadedFile(str(zip_path)), "Default lightweight"
+            )
+
+        # Tuple width unchanged.
+        self.assertEqual(len(outputs), 11)
+        summary = outputs[1]
+        # Batch metadata recorded.
+        self.assertIn("batch", summary)
+        self.assertEqual(summary["batch"]["input_count"], 2)
+        self.assertEqual(summary["batch"]["successful_count"], 2)
+        self.assertEqual(summary["batch"]["failed_count"], 0)
+        self.assertEqual(len(summary["batch"]["documents"]), 2)
+        # Aggregate metrics populated.
+        agg = summary["batch"]["aggregate"]
+        self.assertGreater(agg["total_chunks"], 0)
+        self.assertGreater(agg["mean_quality_score"], 0.0)
+
+    def test_multiple_files_uploaded_as_list(self):
+        if space_app is None:
+            self.skipTest(APP_IMPORT_ERROR)
+
+        with tempfile.TemporaryDirectory() as tmp:
+            doc1 = Path(tmp) / "one.md"
+            doc1.write_text("# One\n\nFirst doc.\n", encoding="utf-8")
+            doc2 = Path(tmp) / "two.md"
+            doc2.write_text("# Two\n\nSecond doc.\n", encoding="utf-8")
+
+            outputs = space_app.parse_uploaded_document(
+                [_UploadedFile(str(doc1)), _UploadedFile(str(doc2))],
+                "Default lightweight",
+            )
+
+        summary = outputs[1]
+        self.assertIn("batch", summary)
+        self.assertEqual(summary["batch"]["input_count"], 2)
+
+    def test_zip_with_unsupported_files_filtered_out(self):
+        if space_app is None:
+            self.skipTest(APP_IMPORT_ERROR)
+
+        import zipfile
+
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            zip_path = tmp_path / "mixed.zip"
+            doc_a = tmp_path / "first.md"
+            doc_a.write_text("# First\n\nContent A.\n", encoding="utf-8")
+            doc_b = tmp_path / "second.md"
+            doc_b.write_text("# Second\n\nContent B.\n", encoding="utf-8")
+            junk = tmp_path / "ignore.exe"
+            junk.write_bytes(b"\x00\x01")
+
+            with zipfile.ZipFile(zip_path, "w") as zf:
+                zf.write(doc_a, arcname="first.md")
+                zf.write(doc_b, arcname="second.md")
+                zf.write(junk, arcname="ignore.exe")
+
+            outputs = space_app.parse_uploaded_document(
+                _UploadedFile(str(zip_path)), "Default lightweight"
+            )
+
+        summary = outputs[1]
+        # The two .md files parsed; the .exe was filtered out before parsing.
+        self.assertIn("batch", summary)
+        self.assertEqual(summary["batch"]["input_count"], 2)
+        self.assertEqual(summary["batch"]["successful_count"], 2)
+
+    def test_chunk_detail_payload_present(self):
+        if space_app is None:
+            self.skipTest(APP_IMPORT_ERROR)
+
+        with tempfile.TemporaryDirectory() as tmp:
+            doc = Path(tmp) / "rich.md"
+            doc.write_text(
+                "# Rich Doc\n\n"
+                "First paragraph with some prose to chunk.\n\n"
+                "Second paragraph with different content for variety.\n\n"
+                "| A | B |\n| --- | --- |\n| 1 | 2 |\n",
+                encoding="utf-8",
+            )
+            outputs = space_app.parse_uploaded_document(
+                _UploadedFile(str(doc)), "Default lightweight"
+            )
+
+        chunking_payload = outputs[4]
+        self.assertIn("plan", chunking_payload)
+        self.assertIn("detail", chunking_payload)
+        detail = chunking_payload["detail"]
+        self.assertGreater(detail["total_chunks"], 0)
+        self.assertIn("strategies", detail)
+        # Each strategy block has the expected shape.
+        for strategy_name, block in detail["strategies"].items():
+            self.assertIn("count", block)
+            self.assertIn("samples", block)
+            self.assertIn("token_count_min", block)
+
+
 if __name__ == "__main__":
     unittest.main()