Add material upload and draft import setup

README.md

@@ -17,6 +17,10 @@ short_description: 'Slide creation AI assistant '
 Gradio workflow console for generating, reviewing, approving, and export-checking
 course slide decks with deterministic P0 trust and readiness gates.
 
+In setup, you can provide course material by uploading text-readable files or by
+specifying a material URL. Either option is acceptable. You can also start from
+zero or import an existing draft deck as `.json` or `.pptx`.
+
 ## Local checks
 
 ```bash

app.py

@@ -46,7 +46,9 @@ def _load_or_update_state(
     output_folder_id: str,
     dry_run: bool,
     objectives_text: str,
-    source_text: str,
+    material_files,
+    start_mode: str,
+    draft_file,
     mutation_target_url: str,
     production_export_requested: bool,
 ):
@@ -69,7 +71,9 @@ def _load_or_update_state(
         output_folder_id=output_folder_id,
         dry_run=dry_run,
         objectives_text=objectives_text,
-        source_text=source_text,
+        material_files=material_files,
+        start_mode=start_mode,
+        draft_file=draft_file,
         mutation_target_url=mutation_target_url or None,
         production_export_requested=production_export_requested,
     )
@@ -104,7 +108,9 @@ def handle_update_setup(
     output_folder_id,
     dry_run,
     objectives_text,
-    source_text,
+    material_files,
+    start_mode,
+    draft_file,
     mutation_target_url,
     production_export_requested,
     stage_id,
@@ -117,7 +123,9 @@ def handle_update_setup(
         output_folder_id,
         dry_run,
         objectives_text,
-        source_text,
+        material_files,
+        start_mode,
+        draft_file,
         mutation_target_url,
         production_export_requested,
     )
@@ -132,7 +140,9 @@ def handle_generate(
     output_folder_id,
     dry_run,
     objectives_text,
-    source_text,
+    material_files,
+    start_mode,
+    draft_file,
     mutation_target_url,
     production_export_requested,
     stage_id,
@@ -145,7 +155,9 @@ def handle_generate(
         output_folder_id,
         dry_run,
         objectives_text,
-        source_text,
+        material_files,
+        start_mode,
+        draft_file,
         mutation_target_url,
         production_export_requested,
     )
@@ -211,6 +223,10 @@ def handle_stage_change(state_data, stage_id):
     return _render_outputs(state, stage_id, f"Selected {STAGE_LABELS[stage_id]}.")
 
 
+def toggle_draft_upload(start_mode):
+    return gr.update(visible=start_mode == "import_existing_draft")
+
+
 def build_app() -> gr.Blocks:
     stage_choices = [(f"{index + 1}. {STAGE_LABELS[stage_id]}", stage_id) for index, stage_id in enumerate(STAGE_IDS)]
     with gr.Blocks(title="Course Slide Factory") as demo:
@@ -220,7 +236,19 @@ def build_app() -> gr.Blocks:
         with gr.Row():
             with gr.Column(scale=1, min_width=320):
                 deck_title = gr.Textbox(label="Deck title", value="Course Slide Deck")
-                source_url = gr.Textbox(label="Source URL", value="mock://source/course")
+                gr.Markdown(
+                    "### Course material\n"
+                    "Use either option: upload material, specify a URL, or provide both. "
+                    "Uploads are used directly when text-readable; URLs are stored for provenance "
+                    "until URL ingestion is added."
+                )
+                material_files = gr.File(
+                    label="Upload material",
+                    file_count="multiple",
+                    file_types=[".txt", ".md", ".csv", ".json", ".pdf", ".docx", ".pptx"],
+                    type="filepath",
+                )
+                source_url = gr.Textbox(label="Material URL", value="mock://source/course")
                 template_url = gr.Textbox(label="Template URL", value="mock://template/course")
                 output_folder_id = gr.Textbox(label="Output folder ID", value="")
                 mutation_target_url = gr.Textbox(label="Mutation target URL", value="")
@@ -235,10 +263,21 @@ def build_app() -> gr.Blocks:
                         "obj_2: Apply the concept to a worked example."
                     ),
                 )
-                source_text = gr.Textbox(
-                    label="Source text",
-                    lines=5,
-                    value="Mock source text for deterministic dry-run generation.",
+                gr.Markdown("### Starting point\nYou can start from zero or import an existing draft.")
+                start_mode = gr.Radio(
+                    label="Start mode",
+                    choices=[
+                        ("Start from zero", "start_from_zero"),
+                        ("Import existing draft", "import_existing_draft"),
+                    ],
+                    value="start_from_zero",
+                )
+                draft_file = gr.File(
+                    label="Existing draft deck (.json or .pptx)",
+                    file_count="single",
+                    file_types=[".json", ".pptx"],
+                    type="filepath",
+                    visible=False,
                 )
                 update_setup = gr.Button("Save Setup", variant="secondary")
 
@@ -392,7 +431,9 @@ def build_app() -> gr.Blocks:
             output_folder_id,
             dry_run,
             objectives_text,
-            source_text,
+            material_files,
+            start_mode,
+            draft_file,
             mutation_target_url,
             production_export_requested,
             stage_id,
@@ -424,6 +465,7 @@ def build_app() -> gr.Blocks:
         preflight.click(handle_preflight, inputs=[state_store, stage_id], outputs=outputs)
         export.click(handle_export, inputs=[state_store, stage_id], outputs=outputs)
         stage_id.change(handle_stage_change, inputs=[state_store, stage_id], outputs=outputs)
+        start_mode.change(toggle_draft_upload, inputs=start_mode, outputs=draft_file)
 
     return demo
 

course_slide_factory/models.py

@@ -332,6 +332,10 @@ class PipelineState(BaseModel):
     template_url: str | None = None
     output_folder_id: str | None = None
     mutation_target_url: str | None = None
+    uploaded_materials: list[dict[str, Any]] = Field(default_factory=list)
+    unsupported_materials: list[dict[str, Any]] = Field(default_factory=list)
+    start_mode: Literal["start_from_zero", "import_existing_draft"] = "start_from_zero"
+    draft_upload_metadata: dict[str, Any] = Field(default_factory=dict)
     source_chunks: dict[str, str] = Field(default_factory=dict)
     objectives: dict[str, str] = Field(default_factory=dict)
     stages: dict[str, StageState] = Field(default_factory=dict)

course_slide_factory/quality.py

@@ -942,13 +942,17 @@ def _deduct_for_issue_types(
 
 def _score_dimension(stage_id: str, dimension_id: str, state: PipelineState) -> tuple[int, str]:
     if stage_id == "setup_inputs":
-        required = [state.deck_title, state.source_url, state.template_url]
+        source_material_present = bool(state.source_url or state.source_chunks)
+        required = [state.deck_title, state.template_url, source_material_present]
         if dimension_id == "required_inputs_present":
-            return (100 if all(required) else 30, "Deck title, source URL, and template URL are checked.")
+            return (
+                100 if all(required) else 30,
+                "Deck title, template URL, and either uploaded material or a material URL are checked.",
+            )
         if dimension_id == "url_validity":
-            urls = [state.source_url or "", state.template_url or ""]
+            urls = [url for url in [state.source_url, state.template_url] if url]
             valid = all(url.startswith(("http://", "https://", "mock://")) for url in urls)
-            return (100 if valid else 40, "Source and template URLs must be explicit URLs.")
+            return (100 if valid else 40, "Provided material/template URLs must be explicit URLs.")
         safe = state.dry_run or bool(state.output_folder_id)
         if state.mutation_target_url and state.mutation_target_url in {state.source_url, state.template_url}:
             safe = False
@@ -1259,12 +1263,12 @@ def _preflight_blocker(
 
 
 def _check_preflight_prerequisites(state: PipelineState) -> None:
-    if not state.deck_title or not state.source_url or not state.template_url:
+    if not state.deck_title or not state.template_url or not (state.source_url or state.source_chunks):
         upsert_issue(
             state,
             IssueType.MISSING_REQUIRED_INPUT,
             IssueSeverity.BLOCKER,
-            "Deck title, source URL, and template URL are required.",
+            "Deck title, template URL, and course material upload or URL are required.",
             stage_id="setup_inputs",
             suggested_fix="Complete setup inputs before export.",
         )

course_slide_factory/workflow.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+from pathlib import Path
 from typing import Any
 
 from .constants import STAGE_IDS, STAGE_LABELS, STAGE_SEQUENCE
@@ -93,6 +94,319 @@ def parse_objective_lines(objectives_text: str | None) -> dict[str, str]:
     return objectives
 
 
+def _normalize_file_paths(file_paths: Any) -> list[Path]:
+    if not file_paths:
+        return []
+    if isinstance(file_paths, str | Path):
+        return [Path(file_paths)]
+    normalized: list[Path] = []
+    for item in file_paths:
+        if isinstance(item, str | Path):
+            normalized.append(Path(item))
+            continue
+        path = getattr(item, "path", None) or getattr(item, "name", None)
+        if path:
+            normalized.append(Path(path))
+    return normalized
+
+
+def _file_content_hash(path: Path) -> str:
+    return stable_hash({"path": path.name, "bytes": path.read_bytes().hex()})
+
+
+def _read_text_file(path: Path) -> str:
+    return path.read_text(encoding="utf-8", errors="replace").strip()
+
+
+def extract_uploaded_source_chunks(file_paths: Any) -> tuple[dict[str, str], list[dict[str, Any]], list[dict[str, Any]]]:
+    chunks: dict[str, str] = {}
+    parsed_materials: list[dict[str, Any]] = []
+    unsupported_materials: list[dict[str, Any]] = []
+    for index, path in enumerate(_normalize_file_paths(file_paths), start=1):
+        suffix = path.suffix.lower()
+        metadata = {
+            "filename": path.name,
+            "path": str(path),
+            "extension": suffix,
+        }
+        if suffix in {".txt", ".md", ".csv"}:
+            text = _read_text_file(path)
+            if text:
+                chunk_id = f"upload_{index}"
+                chunks[chunk_id] = text
+                parsed_materials.append({**metadata, "chunk_id": chunk_id, "parsed": True})
+            continue
+        if suffix == ".json":
+            raw_text = _read_text_file(path)
+            if not raw_text:
+                continue
+            parsed = json.loads(raw_text)
+            chunk_id = f"upload_{index}"
+            chunks[chunk_id] = json.dumps(parsed, indent=2, sort_keys=True)
+            parsed_materials.append({**metadata, "chunk_id": chunk_id, "parsed": True})
+            continue
+        unsupported_materials.append(
+            {
+                **metadata,
+                "parsed": False,
+                "reason": "Only .txt, .md, .csv, and .json material uploads are parsed in this version.",
+            }
+        )
+    return chunks, parsed_materials, unsupported_materials
+
+
+def _sequence_items(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, dict):
+        return list(value.values())
+    if isinstance(value, list):
+        return value
+    return []
+
+
+def _import_json_draft(path: Path) -> dict[str, Any]:
+    data = json.loads(_read_text_file(path))
+    if not isinstance(data, dict):
+        raise ValueError("Draft JSON must be an object.")
+
+    objectives = data.get("objectives") or {}
+    source_chunks = data.get("source_chunks") or {}
+    slides = [
+        model_validate(Slide, item)
+        for item in _sequence_items(data.get("slides"))
+    ]
+    claims = [
+        model_validate(SlideClaim, item)
+        for item in _sequence_items(data.get("claims"))
+    ]
+    visual_assets = [
+        model_validate(VisualAsset, item)
+        for item in _sequence_items(data.get("visual_assets"))
+    ]
+    layout_specs = [
+        model_validate(LayoutSpec, item)
+        for item in _sequence_items(data.get("layout_specs"))
+    ]
+    return {
+        "objectives": objectives,
+        "source_chunks": source_chunks,
+        "slides": slides,
+        "claims": claims,
+        "visual_assets": visual_assets,
+        "layout_specs": layout_specs,
+        "metadata": {"format": "json", "filename": path.name},
+    }
+
+
+def _slide_notes_text(slide: Any) -> str | None:
+    try:
+        notes_slide = slide.notes_slide
+        text_frame = getattr(notes_slide, "notes_text_frame", None)
+        if text_frame and getattr(text_frame, "text", None):
+            return text_frame.text.strip()
+    except (AttributeError, KeyError, ValueError):
+        return None
+    return None
+
+
+def _import_pptx_draft(path: Path) -> dict[str, Any]:
+    try:
+        from pptx import Presentation
+    except ImportError as exc:
+        raise RuntimeError("python-pptx is required to import PPTX drafts.") from exc
+
+    presentation = Presentation(str(path))
+    slides: list[Slide] = []
+    for index, pptx_slide in enumerate(presentation.slides, start=1):
+        text_runs: list[str] = []
+        title = None
+        if pptx_slide.shapes.title and pptx_slide.shapes.title.has_text_frame:
+            title = pptx_slide.shapes.title.text.strip() or None
+        for shape in pptx_slide.shapes:
+            if not getattr(shape, "has_text_frame", False):
+                continue
+            text = shape.text.strip()
+            if text:
+                text_runs.append(text)
+        deduped_text = [text for text in text_runs if text != title]
+        bullet_points = []
+        for text in deduped_text:
+            bullet_points.extend([line.strip() for line in text.splitlines() if line.strip()])
+        slide_id = f"slide_{index}"
+        notes_text = _slide_notes_text(pptx_slide)
+        slides.append(
+            Slide(
+                slide_id=slide_id,
+                slide_number=index,
+                title=title or f"Imported slide {index}",
+                visible_text="\n".join(deduped_text),
+                bullet_points=bullet_points,
+                pedagogical_role=PedagogicalRole.UNKNOWN,
+                speaker_notes=(
+                    SpeakerNotes(slide_id=slide_id, notes_text=notes_text)
+                    if notes_text
+                    else None
+                ),
+            )
+        )
+    return {
+        "objectives": {},
+        "source_chunks": {},
+        "slides": slides,
+        "claims": [],
+        "visual_assets": [],
+        "layout_specs": [],
+        "metadata": {"format": "pptx", "filename": path.name},
+    }
+
+
+def import_existing_draft(file_path: Any) -> dict[str, Any]:
+    paths = _normalize_file_paths(file_path)
+    if not paths:
+        return {}
+    path = paths[0]
+    suffix = path.suffix.lower()
+    if suffix == ".json":
+        return _import_json_draft(path)
+    if suffix == ".pptx":
+        return _import_pptx_draft(path)
+    raise ValueError("Existing draft upload must be a .json or .pptx file.")
+
+
+def _apply_imported_draft(state: PipelineState, draft: dict[str, Any], file_hash: str) -> None:
+    if draft.get("objectives"):
+        state.objectives = dict(draft["objectives"])
+    if draft.get("source_chunks"):
+        state.source_chunks.update(dict(draft["source_chunks"]))
+    for slide in draft.get("slides", []):
+        state.slides[slide.slide_id] = slide
+    for claim in draft.get("claims", []):
+        state.claims[claim.claim_id] = claim
+    for asset in draft.get("visual_assets", []):
+        state.visual_assets[asset.asset_id] = asset
+    for layout in draft.get("layout_specs", []):
+        state.layout_specs[layout.slide_id] = layout
+
+    imported_content = {
+        "slides": [model_to_dict(slide) for slide in draft.get("slides", [])],
+        "claims": [model_to_dict(claim) for claim in draft.get("claims", [])],
+        "visual_assets": [model_to_dict(asset) for asset in draft.get("visual_assets", [])],
+        "layout_specs": [model_to_dict(layout) for layout in draft.get("layout_specs", [])],
+        "metadata": draft.get("metadata", {}),
+    }
+    created_stage_ids: list[str] = []
+    if draft.get("objectives") or draft.get("source_chunks"):
+        create_artifact_version(
+            state,
+            "source_extraction_objective_mapping",
+            {
+                "objectives": state.objectives,
+                "source_chunks": state.source_chunks,
+                "import_metadata": draft.get("metadata", {}),
+            },
+            created_by="human",
+            status=ArtifactStatus.CANDIDATE,
+            mark_downstream_stale=False,
+        )
+        created_stage_ids.append("source_extraction_objective_mapping")
+    if draft.get("slides"):
+        create_artifact_version(
+            state,
+            "slide_outline_order",
+            imported_content,
+            created_by="human",
+            status=ArtifactStatus.CANDIDATE,
+            mark_downstream_stale=False,
+        )
+        create_artifact_version(
+            state,
+            "title_generation",
+            {"titles": {slide.slide_id: slide.title for slide in draft["slides"]}},
+            created_by="human",
+            status=ArtifactStatus.CANDIDATE,
+            mark_downstream_stale=False,
+        )
+        create_artifact_version(
+            state,
+            "text_generation",
+            imported_content,
+            created_by="human",
+            status=ArtifactStatus.CANDIDATE,
+            mark_downstream_stale=False,
+        )
+        created_stage_ids.extend(["slide_outline_order", "title_generation", "text_generation"])
+    if draft.get("visual_assets"):
+        create_artifact_version(
+            state,
+            "image_visual_asset_generation",
+            imported_content,
+            created_by="human",
+            status=ArtifactStatus.CANDIDATE,
+            mark_downstream_stale=False,
+        )
+        created_stage_ids.append("image_visual_asset_generation")
+    if draft.get("layout_specs"):
+        create_artifact_version(
+            state,
+            "aesthetic_ordering_visual_composition",
+            imported_content,
+            created_by="human",
+            status=ArtifactStatus.CANDIDATE,
+            mark_downstream_stale=False,
+        )
+        created_stage_ids.append("aesthetic_ordering_visual_composition")
+
+    state.draft_upload_metadata = {
+        **draft.get("metadata", {}),
+        "content_hash": file_hash,
+        "created_stage_ids": created_stage_ids,
+        "imported_at": now_iso(),
+    }
+    record_audit(
+        state,
+        "draft_imported",
+        metadata={
+            "filename": state.draft_upload_metadata.get("filename"),
+            "format": state.draft_upload_metadata.get("format"),
+            "created_stage_ids": created_stage_ids,
+        },
+    )
+
+
+def apply_setup_material_inputs(
+    state: PipelineState,
+    *,
+    material_files: Any = None,
+    source_text: str | None = None,
+    start_mode: str = "start_from_zero",
+    draft_file: Any = None,
+) -> PipelineState:
+    state.start_mode = (
+        "import_existing_draft"
+        if start_mode == "import_existing_draft"
+        else "start_from_zero"
+    )
+    uploaded_chunks, parsed_materials, unsupported_materials = extract_uploaded_source_chunks(material_files)
+    if uploaded_chunks:
+        state.source_chunks = uploaded_chunks
+    if parsed_materials:
+        state.uploaded_materials = parsed_materials
+    if unsupported_materials:
+        state.unsupported_materials = unsupported_materials
+    if source_text and source_text.strip():
+        state.source_chunks = {"pasted_text": source_text.strip(), **state.source_chunks}
+
+    if state.start_mode == "import_existing_draft":
+        draft_paths = _normalize_file_paths(draft_file)
+        if draft_paths:
+            file_hash = _file_content_hash(draft_paths[0])
+            if state.draft_upload_metadata.get("content_hash") != file_hash:
+                draft = import_existing_draft(draft_paths[0])
+                _apply_imported_draft(state, draft, file_hash)
+    return state
+
+
 def update_setup_from_inputs(
     state: PipelineState,
     *,
@@ -102,7 +416,10 @@ def update_setup_from_inputs(
     output_folder_id: str | None,
     dry_run: bool,
     objectives_text: str | None,
-    source_text: str | None,
+    source_text: str | None = None,
+    material_files: Any = None,
+    start_mode: str = "start_from_zero",
+    draft_file: Any = None,
     mutation_target_url: str | None = None,
     production_export_requested: bool = False,
 ) -> PipelineState:
@@ -116,8 +433,13 @@ def update_setup_from_inputs(
     parsed_objectives = parse_objective_lines(objectives_text)
     if parsed_objectives:
         state.objectives = parsed_objectives
-    if source_text and source_text.strip():
-        state.source_chunks = {"chunk_1": source_text.strip()}
+    apply_setup_material_inputs(
+        state,
+        material_files=material_files,
+        source_text=source_text,
+        start_mode=start_mode,
+        draft_file=draft_file,
+    )
     return state
 
 

requirements.txt

@@ -1,4 +1,5 @@
 gradio==6.19.0
 pydantic>=2.7
+python-pptx>=1.0.2
 pytest>=8.0
 ruff>=0.8

tests/test_p0_quality.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import json
+
 from course_slide_factory.constants import STAGE_IDS
 from course_slide_factory.fixtures import (
     invalid_layout_job,
@@ -33,6 +35,7 @@ from course_slide_factory.workflow import (
     generate_stage,
     improve_with_ai,
     save_human_edits,
+    update_setup_from_inputs,
 )
 
 
@@ -251,3 +254,158 @@ def test_artifact_diff_supports_text_and_json():
 
     assert "-alpha" in text_diff
     assert '+  "b": 3' in json_diff
+
+
+def test_setup_passes_with_uploaded_text_material_only(tmp_path):
+    material_path = tmp_path / "course-notes.md"
+    material_path.write_text("These uploaded notes describe the course objective.", encoding="utf-8")
+    state = build_empty_state()
+
+    update_setup_from_inputs(
+        state,
+        deck_title="Uploaded Material Deck",
+        source_url=None,
+        template_url="mock://template/course",
+        output_folder_id=None,
+        dry_run=True,
+        objectives_text="obj_1: Explain uploaded source material.",
+        material_files=[str(material_path)],
+    )
+    result = grade_stage("setup_inputs", state)
+
+    assert result.passed_threshold
+    assert state.source_chunks["upload_1"].startswith("These uploaded notes")
+    assert state.uploaded_materials[0]["parsed"] is True
+
+
+def test_setup_passes_with_material_url_only():
+    state = build_empty_state()
+
+    update_setup_from_inputs(
+        state,
+        deck_title="URL Material Deck",
+        source_url="https://example.com/course-notes",
+        template_url="mock://template/course",
+        output_folder_id=None,
+        dry_run=True,
+        objectives_text="obj_1: Explain URL-backed material.",
+    )
+    result = grade_stage("setup_inputs", state)
+
+    assert result.passed_threshold
+    assert state.source_url == "https://example.com/course-notes"
+    assert state.source_chunks == {}
+
+
+def test_setup_fails_without_upload_or_material_url():
+    state = build_empty_state()
+
+    update_setup_from_inputs(
+        state,
+        deck_title="Missing Material Deck",
+        source_url=None,
+        template_url="mock://template/course",
+        output_folder_id=None,
+        dry_run=True,
+        objectives_text="obj_1: Explain the material.",
+    )
+    result = grade_stage("setup_inputs", state)
+
+    assert not result.passed_threshold
+
+
+def test_imported_json_draft_creates_structured_candidate_artifacts(tmp_path):
+    draft_path = tmp_path / "draft.json"
+    draft_path.write_text(
+        json.dumps(
+            {
+                "objectives": {"obj_1": "Explain imported draft flow."},
+                "slides": [
+                    {
+                        "slide_id": "slide_1",
+                        "slide_number": 1,
+                        "title": "Imported Draft Slide",
+                        "visible_text": "Imported draft text.",
+                        "bullet_points": ["Review source", "Approve candidate"],
+                        "objective_ids": ["obj_1"],
+                        "pedagogical_role": "concept",
+                        "speaker_notes": {
+                            "slide_id": "slide_1",
+                            "notes_text": "Imported notes for the instructor.",
+                        },
+                    }
+                ],
+                "claims": [
+                    {
+                        "claim_id": "claim_1",
+                        "slide_id": "slide_1",
+                        "claim_text": "Imported draft text.",
+                        "review_status": "unsupported",
+                    }
+                ],
+                "layout_specs": [
+                    {
+                        "slide_id": "slide_1",
+                        "layout_id": "title_body",
+                        "approved_template_id": "default_course_template",
+                        "slot_assignments": {
+                            "title": "Imported Draft Slide",
+                            "body": "Imported draft text.",
+                        },
+                    }
+                ],
+                "visual_assets": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+    state = build_empty_state()
+
+    update_setup_from_inputs(
+        state,
+        deck_title="Imported JSON Draft",
+        source_url="mock://source/imported",
+        template_url="mock://template/course",
+        output_folder_id=None,
+        dry_run=True,
+        objectives_text=None,
+        start_mode="import_existing_draft",
+        draft_file=str(draft_path),
+    )
+
+    assert state.start_mode == "import_existing_draft"
+    assert state.slides["slide_1"].title == "Imported Draft Slide"
+    assert state.slides["slide_1"].speaker_notes.notes_text == "Imported notes for the instructor."
+    assert state.layout_specs["slide_1"].layout_id == "title_body"
+    assert state.claims["claim_1"].review_status == "unsupported"
+    assert get_current_stage_artifact("slide_outline_order", state).status == ArtifactStatus.CANDIDATE
+    assert get_current_stage_artifact("text_generation", state).status == ArtifactStatus.CANDIDATE
+    assert not has_valid_human_approval("slide_outline_order", state)
+
+
+def test_imported_pptx_draft_creates_slide_records(tmp_path):
+    from pptx import Presentation
+
+    draft_path = tmp_path / "draft.pptx"
+    presentation = Presentation()
+    title_slide = presentation.slides.add_slide(presentation.slide_layouts[1])
+    title_slide.shapes.title.text = "PPTX Imported Slide"
+    title_slide.placeholders[1].text = "First bullet\nSecond bullet"
+    presentation.save(draft_path)
+    state = build_empty_state()
+
+    update_setup_from_inputs(
+        state,
+        deck_title="Imported PPTX Draft",
+        source_url="mock://source/imported",
+        template_url="mock://template/course",
+        output_folder_id=None,
+        dry_run=True,
+        objectives_text=None,
+        start_mode="import_existing_draft",
+        draft_file=str(draft_path),
+    )
+
+    assert state.slides["slide_1"].title == "PPTX Imported Slide"
+    assert "First bullet" in state.slides["slide_1"].visible_text
+    assert get_current_stage_artifact("slide_outline_order", state).status == ArtifactStatus.CANDIDATE