Paper Engineering Assistant

1. Skill Description

This skill automates a structured academic writing workflow based on a three-layer architecture: Framework Layer, Summary Layer, and Body Layer. It maintains data consistency across all layers through automatic synchronization mechanisms. The skill operates within a user-designated project directory (default: ./PaperProject/).

2. When to Use

Use this skill when the user needs systematic assistance with academic writing, especially for long-form documents like theses or dissertations.

• User says: "Start working on my thesis."
• User says: "Read and structure all literature in the references folder."
• User says: "Generate a preliminary framework based on my research proposal."
• User says: "I've modified Section 2.1, please sync the framework and summaries."
• User says: "Find and download recent literature about 'performance management'."

3. Core Concepts & Workflow

This skill strictly follows the three-layer architecture:

A. Core Three-Layer Structure

1. Framework Layer (structs.json): The blueprint/map of the entire paper. A JSON array describing the hierarchical structure of chapters, sections, and paragraphs with IDs, titles, abstracts, keywords, and key points.
2. Summary Layer (summaries.json): The content database. Provides detailed summaries for each framework node and records related node IDs for content traceability.
3. Body Layer (./document_body/ directory): The actual written content. A directory and Markdown file collection that exactly mirrors the framework layer structure, with each file corresponding to a writing unit.

B. Workflow Stages

Stage 1: Literature Review & Processing

1. Initialization: Create necessary subdirectories in the project directory (e.g., ./document_body/, ./processed_references/).
2. Process References:
• Iterate through each reference in the references directory.
• Create a dedicated folder for each reference (named after the reference) and initialize an information.md file with metadata (title, author, abstract, keywords, download link).
• If the reference file (e.g., PDF) is available, parse it using the same three-layer architecture, generating corresponding structs.json, summaries.json, and body files stored within that reference's folder. This creates a "knowledge base" for each reference.
• If the original text cannot be downloaded, only save the information.md.
3. Read Other Materials: Review non-reference materials like research proposals, institutional guidelines, etc., to understand requirements and existing foundations.

Stage 2: Document Writing

1. Generate Framework Layer: Create the initial structs.json based on the research topic, proposal, and processed references. If an exemplary reference paper exists, its structure can be emulated.
2. Generate Summary Layer: Write detailed summaries for each framework node, forming summaries.json.
3. Write Body Layer: Based on the framework structure and summary content, write detailed content for each part in the ./document_body/ directory, following the format Chapter_X/Section_X.X_Title.md. If a section becomes too long, split it into multiple files (e.g., Section_X.X_Title_trunc_1.md).

Stage 3: Assembly & Synchronization

1. Assemble Final Document: Run a concatenation script that reads all Markdown files in ./document_body/ and merges them in the order defined by the framework layer into a complete thesis_final.md file. This is a programmatic process, not reliant on AI.
2. Critical: Synchronization Mechanism:
• Top-down Modification: When the user or AI modifies the Framework Layer (structs.json) or Summary Layer (summaries.json), the corresponding Body Layer files must be rewritten or updated.
• Bottom-up Modification: When the user or AI modifies a Body Layer file, extract its core information to update the corresponding Summary Layer entry and Framework Layer abstract.
• This synchronization is crucial for maintaining logical consistency and preventing fragmentation, and must be executed after each modification.

4. How to Use (Operating Steps)

When the user triggers the skill, I will work according to the following logic:

1. Confirm Working Directory: I will first establish the project root directory. If not specified, I will use the default ./PaperProject/ in the current working directory. All generated files will be placed within this directory or its subdirectories.
2. Execute the Requested Task:
• If the request is "start" or "process references":

a. Check the directory structure and list all items in the references folder.

b. Execute the "Literature Review & Processing" workflow for each item.

c. Generate a literature_review_report.md summarizing key findings and interconnections.

• If the request is "generate framework":

a. Comprehensively analyze the research proposal, core insights from processed references, and institutional guidelines.

b. Generate or update structs.json (Framework Layer) in the project root.

• If the request is "write body":

a. Read structs.json and summaries.json.

b. Create corresponding folders and files in the ./document_body/ directory and begin writing content. Existing files in this directory may be overwritten.

c. While writing each section, query summaries.json and the associated reference knowledge bases.

• If the request is "sync modification":

a. The user indicates which file was modified (e.g., ./document_body/Chapter_3/3.1_Current_Analysis.md).

b. I first read the modified file content, extract a new abstract and key points.

c. Update the section_summary for the corresponding section_id in summaries.json.

d. Update the abstract and key_points for the corresponding section_id in structs.json.

• If the request is "find literature":

a. Perform a network search based on the user-provided keywords.

b. Attempt to download PDFs to the references directory.

c. Create a folder and information.md for each, regardless of download success. If downloaded successfully, proceed with structured parsing.

1. Output & Confirmation: After each operation, I will clearly state which files were generated, their paths, and briefly describe their content.

5. Edge Cases

• Directory Doesn't Exist: If the project directory doesn't exist, I will ask the user if they want to create it.
• References Folder Empty: If the references folder is empty, I will notify the user and ask if they want to proceed directly to framework design or start a network search for literature.
• Research Proposal Missing: If no research proposal is found, I will generate a very basic initial framework based on the paper title and general academic structure, noting that it will require significant revision.
• Sync Conflict: If major, irreconcilable discrepancies are detected between the Framework, Summary, and Body layers for the same section, I will list the conflicts and pause automatic synchronization, requesting manual user judgment and instruction.