# How Design Patent Disclosures Are Generated in the *patent-disclosure-skill* Repository

> Discover how design patent disclosures are generated using a six-stage pipeline in the patent-disclosure-skill repository. Learn about schema validation, generation modes, and final document assembly.

- Repository: [handsomestWei/patent-disclosure-skill](https://github.com/handsomestWei/patent-disclosure-skill)
- Tags: how-to-guide
- Published: 2026-09-04

---

**Design patent disclosures are generated through a six-stage pipeline that validates design briefs against a strict schema, selects between existing line-art, image-to-image, or text-to-image generation modes, and assembles final markdown and Word documents while enforcing a strict prohibition against including CAD diagrams.**

The `patent-disclosure-skill` repository implements a deterministic workflow for transforming raw design materials—CAD files, reference photos, and textual specifications—into complete disclosure documents. This system orchestrates the entire process through specialized Python tools that enforce scoring thresholds and content policies. Understanding how design patent disclosures are generated requires tracing the pipeline from source collection through final document assembly.

## Stage 1: Collecting Source Material and Figure Plans

The process begins in the case directory, where a **[`figure_plan.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/figure_plan.yaml)** (or `.json`) file catalogs every figure extracted during the patent search phase. Each entry in this plan carries a `kind` attribute—such as `photo_clean`, `cad`, or `lineart`—and a `role` designation indicating whether it was `rejected` or accepted.

In [`skills/patent-disclosure/tools/image_gen.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/image_gen.py), the function `load_plan` reads this configuration, while `pick_design_photos` and `pick_sources` filter the available assets. The system also invokes `qualified_lineart` to identify any existing line-art files that meet quality thresholds. Only materials passing these initial filters proceed to the validation stage.

## Stage 2: Validating the Design Line-Art Brief

Before generation begins, the system validates the **[`design_lineart_brief.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/design_lineart_brief.yaml)** file against the schema defined in [`design_lineart_brief.schema.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/design_lineart_brief.schema.yaml). This brief specifies the overall shape, the faces to be claimed, and any prohibited elements that must be excluded from the final output.

The `run_check` function in [`skills/patent-disclosure/tools/design_lineart_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/design_lineart_gate.py) orchestrates this validation, calling `validate_brief` to ensure all required fields are present and that referenced images actually exist on disk. If validation fails, the function returns a list of specific errors; if successful, the pipeline proceeds to mode selection.

```python

# Example: Validate a design line-art brief

from skills.patent_disclosure.tools.design_lineart_gate import run_check, parse_enabled
from pathlib import Path

case_dir = Path("outputs/example_case")
enabled = parse_enabled(cli_flag=False, skip=False)
result = run_check(case_dir, enabled=enabled)
if result["ok"]:
    print("Brief is valid")
else:
    print("Errors:", result["errors"])

```

## Stage 3: Deciding the Generation Mode

The planner module evaluates three possible line-art sources using the `decide_mode` function in [`image_gen.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/image_gen.py). This function returns a JSON decision object containing the selected `mode`, any `fallback` options, and policy flags such as `cad_never_in_disclosure`.

The selection hierarchy follows this priority:

- **Existing qualified line-art** – Used when available files score ≥ 70 % (the `MIN_LINEART_SCORE` threshold).
- **Image-to-image (img2img)** – Triggered when reference images exist and meet the minimum source score of ≥ 50 % (`MIN_SOURCE_SCORE`).
- **Text-to-image (txt2img)** – Deployed as a fallback when no qualified reference images are available.

Critically, the system flags CAD diagrams as "material only" through the `cad_never_in_disclosure` flag. These files are excluded from the disclosure entirely and never used as line-art.

```python

# Example: Decide the generation mode for a case directory

from skills.patent_disclosure.tools.image_gen import load_plan, decide_mode
from pathlib import Path

case_dir = Path("outputs/example_case")
plan = load_plan(case_dir)                # reads figure_plan.yaml / .json

decision = decide_mode(plan, case_dir)    # returns mode, fallback, etc.

print(decision["mode"])                  # → "existing_lineart" | "img2img" | "txt2img"

```

## Stage 4: Building the Line-Art Jobs

Once the mode is determined, the system constructs a job record for each view defined in the brief. The `build_jobs` function in [`design_lineart_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/design_lineart_gate.py) (coordinated with `attach_job_mode` in [`image_gen.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/image_gen.py)) assembles the following for each view:

- Resolved source image paths (`source_paths`).
- A generated prompt embedding the product name, overall shape, and specific design points.
- The intended output path (`lineart_assist/<view>_lineart.png`).

These job specifications are serialized to [`lineart_assist/design_lineart_jobs.json`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/lineart_assist/design_lineart_jobs.json), which serves as the instruction set for the host image-generation service.

```bash

# Example CLI: Prepare line-art jobs after a successful validation

python tools/design_lineart_gate.py \
    --case-dir outputs/example_case \
    --prepare-jobs

# Produces: outputs/example_case/lineart_assist/design_lineart_jobs.json

```

## Stage 5: Rendering Line-Art via the Host

The actual rendering is delegated to an external host LLM or image-generation service. The host reads [`design_lineart_jobs.json`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/design_lineart_jobs.json) and executes according to the `gen_mode` field:

- **Existing line-art** files are copied directly without modification.
- **Img2img** processing uses the provided reference images as structural guides.
- **Txt2img** generation creates new line-art from the embedded text prompts when no references exist.

All outputs are forced to black-and-white line art. The system explicitly prohibits color, logos, and internal structures in the final images.

## Stage 6: Assembling the Final Disclosure Document

In the final stage, the system aggregates all approved visual assets into publication formats. The `design_photos_in_disclosure` logic automatically embeds clean product photos (`photo_clean` kind) into the output when the patent type is `design`.

The assembly process invokes:

- [`skills/patent-disclosure/tools/mermaid_render.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/mermaid_render.py) – Renders any Mermaid diagrams (such as claim trees).
- [`skills/patent-disclosure/tools/md_to_docx.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-disclosure/tools/md_to_docx.py) – Converts the markdown disclosure into a Word document while embedding line-art images and photos.

The final deliverables include [`disclosure.md`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/disclosure.md) and `disclosure.docx`, both containing the validated line-art and photography but strictly excluding any CAD source files.

## Key Constraints and Scoring Thresholds

The repository enforces strict policies to ensure compliance with design patent standards:

- **CAD Exclusion** – CAD diagrams are tagged `cad_never_in_disclosure` and treated as "material only." They are never embedded in the disclosure or converted to line-art (see `decide_mode` in [`image_gen.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/image_gen.py), lines 8‑10).
- **Quality Thresholds** – Existing line-art must score ≥ 70 % (`MIN_LINEART_SCORE`), while source reference images require ≥ 50 % (`MIN_SOURCE_SCORE`). These checks are implemented in `is_qualified_existing_lineart` and `is_source_candidate`.

## Summary

- The pipeline requires a valid [`figure_plan.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/figure_plan.yaml) listing all source images and a [`design_lineart_brief.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/design_lineart_brief.yaml) defining the design views and constraints.
- **Three generation modes** are supported: existing line-art, img2img, and txt2img, selected automatically based on file availability and quality scores.
- **CAD files are strictly prohibited** from appearing in final disclosures, while clean product photos (`photo_clean`) are automatically embedded for design patents.
- The system outputs both markdown and Word documents via [`md_to_docx.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/md_to_docx.py) and [`mermaid_render.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/mermaid_render.py), with all line-art rendered in black-and-white without logos or internal structures.

## Frequently Asked Questions

### Why are CAD diagrams excluded from design patent disclosures?

According to the source code in [`image_gen.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/image_gen.py), CAD diagrams are flagged with `cad_never_in_disclosure` and treated exclusively as "material only" references. This policy ensures that the final disclosure contains only polished line-art suitable for patent submission, avoiding the technical clutter and perspective distortions common in raw CAD exports.

### What score thresholds determine if an image can be used in the disclosure?

The system enforces a **70% minimum score** (`MIN_LINEART_SCORE`) for existing line-art to be used directly, and a **50% minimum score** (`MIN_SOURCE_SCORE`) for reference images to qualify as img2img candidates. These thresholds are checked in the `is_qualified_existing_lineart` and `is_source_candidate` functions within the image generation tools.

### How does the system choose between img2img and txt2img generation?

The `decide_mode` function evaluates availability in a strict hierarchy: it first checks for existing qualified line-art (≥ 70% score), then falls back to img2img if reference photos exist and meet the 50% threshold, and finally resorts to txt2img only when no suitable reference images are available. This decision is recorded in the `mode` field of the JSON decision object.

### What files are required to initiate the design patent disclosure workflow?

The pipeline requires two primary configuration files in the case directory: [`figure_plan.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/figure_plan.yaml) (or `.json`) listing all figures with their kinds and roles, and [`design_lineart_brief.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/design_lineart_brief.yaml) specifying the design views, overall shape, and prohibited elements. The brief must validate against [`design_lineart_brief.schema.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/design_lineart_brief.schema.yaml) before job generation can proceed.