NSFC Proposal Expert Review Simulator

Important Disclaimer (Non-Official)

• The output of this skill is only for writing improvement and self-checking, and does not represent any official review caliber, nor does it constitute a funding conclusion or commitment.
• The "review grade/funding recommendation" is only for reference as priority and improvement direction; this section may be omitted if the user does not explicitly request it.

Skill Dependencies

• Parallel multi-group review mode depends on the

  parallel-vibe

  skill.
• If

  parallel-vibe

  is unavailable, disabled, or

  panel_count == 1

  , it automatically degrades to single-group mode (still includes 5 experts).
• Expert prompt templates are located in

  references/expert_*.md

  , and aggregation rules are in

  references/aggregation_rules.md

  .

Security and Privacy (Hard Rules)

• By default, proposal content is treated as sensitive information: only process files/directories explicitly provided by the user; do not expand the scanning scope without permission.
• Unless explicitly requested by the user and risks are confirmed: no internet access, do not send large segments of the original text externally, and do not repeat unnecessary personal/unit information in the output.
• Only perform "text reading and review"; by default, do not execute any compilation/running (e.g., do not run LaTeX compilation, do not execute scripts).
• If output needs to be shared: prioritize providing "issue summary + actionable modification suggestions"; when necessary to quote the original text, only quote the shortest necessary fragment.

Input

• proposal_path

  : Proposal directory (recommended, containing multiple

  .tex

  files)

• proposal_file

  : Single main

  .tex

  file (if the user only has one file)

• proposal_zip

  : Compressed package (if provided, first extract to a temporary directory for review, and record the extraction location in the report)
  • Extraction security: Prohibit path traversal (e.g.,

    ../

    ); avoid overwriting existing user files; if necessary, ask the user to confirm the extraction location first.

• focus

  : Prioritize a specific dimension (e.g., "innovation/feasibility/research foundation")

• output_path

  : Output file path (default see "Output")

• style

  : Tone preference (e.g., "strict/moderate/very specific")

• panel_count

  : Number of review panels (each panel has 5 fixed experts)
  • Default value see

    config.yaml:parallel_review.default_panel_count

  • Upper limit see

    config.yaml:parallel_review.max_panel_count

Output

• Default output filename see

  config.yaml:output_settings.default_filename

  , which is written to the proposal directory by default:

  ./{default_filename}

  .
• If the user specifies

  output_path

  , follow the user's setting; but if the path is unwritable or the directory does not exist, fail fast and prompt the user to change the path.
• In parallel mode, output "expert consensus + independent opinions + aggregated suggestions"; original opinions of each expert can be attached as per configuration.
• In parallel mode, it is recommended to organize the original reviews of each panel into final deliverable files:

  ./{panel_dir}/G{panel_number}.md

  (

  panel_dir

  see

  config.yaml:output_settings.panel_dir

  ).
• Intermediate files are hidden in

  config.yaml:output_settings.intermediate_dir

  by default (default

  .nsfc-reviewers/

  ) to avoid cluttering the root directory with plans, logs, and parallel runtime environments.

Workflow (Execution Specifications)

Read Configuration (Mandatory)

config.yaml

• review_dimensions

  : Review dimensions, weights, key points, and common issues (as a checklist)

• severity_levels

  : P0/P1/P2 grading criteria (for classification)

• review_grades

  : Grades and suggestions (only output if requested by the user)

• proposal_files.patterns/exclude

  : Proposal file identification rules

• output_settings

  : Output filename, panel directory, intermediate process hiding strategy, and chapter switches

• parallel_review

  : Parallel review switch, expert personas, aggregation strategy

Phase 1: Pre-Check (Fail Fast)

1. Verify that the input path exists and is readable; if it is a directory, first filter the list of files to be read according to the

   proposal_files

   rules.
2. If the number of

   .tex

   files is 0: directly report an error and request the user to provide the correct path/file.
3. If the number of files is abnormally large or the directory obviously contains a large number of irrelevant files: first ask the user to confirm the review scope (to avoid reading the wrong directory or too many files).

# List .tex files to be included in the review (recursive scan, automatically skipping panels/, .nsfc-reviewers/, .parallel_vibe/)
python3 <nsfc_reviewers_path>/scripts/list_proposal_files.py --proposal-path <proposal_root>

# Optional: Limit maximum number of files (exit code=3 if exceeded)
python3 <nsfc_reviewers_path>/scripts/list_proposal_files.py --proposal-path <proposal_root> --max-files 200

Phase 2: Read-Through and Structured Understanding

1. Quickly read through the proposal in chapter order, extracting "project topic/scientific hypothesis/objectives/technical route/innovation points/research foundation/team and conditions/expected outcomes".
2. Generate a "proposal structure index" (only to chapter level) as a positioning anchor for subsequent references.

Phase 3: Parallel Multi-Group Review (Priority) or Single-Group Mode (Degradation)

Pre-Judgment

1. Calculate

   effective_panel_count

   : prioritize user input

   panel_count

   , otherwise use

   parallel_review.default_panel_count

   .
2. Limit

   effective_panel_count

   to

   [1, parallel_review.max_panel_count]

   .
3. Directly use single-group mode if any of the following conditions are met:

   • parallel_review.enabled == false

   • effective_panel_count == 1

   • Cannot find the

     parallel-vibe

     script

parallel-vibe Script Path Discovery Order

1. ~/.claude/skills/parallel-vibe/scripts/parallel_vibe.py

2. ~/.codex/skills/parallel-vibe/scripts/parallel_vibe.py

3. <current_repository>/parallel-vibe/scripts/parallel_vibe.py

Parallel Mode Steps

1. Prepare Intermediate Directory Structure (Highly Recommended):

mkdir -p <proposal_root>/<intermediate_dir>/{logs/plans,snapshot}

• <intermediate_dir>

  corresponds to

  config.yaml:output_settings.intermediate_dir

  (default

  .nsfc-reviewers

  ).

1. Construct Master Prompt (completed by the host AI):
   • Read 5 expert personas from

     references/expert_*.md

     (corresponding to

     config.yaml:parallel_review.reviewer_personas[*].prompt_file

     )
   • Read the master prompt template from

     references/master_prompt_template.md

   • Inject context: "proposal structure index + key information summary" produced in Phase 2
   • Inject unified quality threshold: issue classification, evidence anchors, output format
   • Inject independence constraints: each expert makes independent judgments without assuming other experts' opinions
   • Inject output constraints: write the panel's output to

     config.yaml:parallel_review.panel_output_filename

     in the root directory of the current thread's

     workspace/

   • Replace template placeholders: replace

     {panel_output_filename}

     with

     config.yaml:parallel_review.panel_output_filename

   • Save the master prompt to a temporary file (recommended to be placed in

     <proposal_root>/<intermediate_dir>/logs/

     for easy tracing without polluting the root directory), recorded as

     <master_prompt_path>

2. Generate parallel-vibe Plan File (Mandatory):
   • Reason: Avoid escaping ultra-long prompts in the CLI; and avoid the automatic splitting logic of

     parallel-vibe --prompt

     (this skill requires "the same master prompt to be executed repeatedly in N independent workspaces")
   • Prioritize using the built-in script of this skill to generate the plan file:

python3 <nsfc_reviewers_path>/scripts/build_parallel_vibe_plan.py \
  --panel-count <effective_panel_count> \
  --master-prompt-file <master_prompt_path> \
  --out <plan_json_path>

• If the script cannot be used, manually generate

  plan.json

  (minimum structure):

{
  "plan_version": 1,
  "prompt": "nsfc-reviewers parallel panels",
  "threads": [
    {
      "thread_id": "001",
      "title": "Panel G001",
      "runner": { "type": "<config:parallel_review.runner>", "profile": "<config:parallel_review.runner_profile>", "model": "", "args": [] },
      "prompt": "<master_prompt>"
    }
  ],
  "synthesis": { "enabled": false }
}

1. Call parallel-vibe (Based on Plan File):

• It is recommended to prepare a proposal snapshot (e.g.,

  proposal_snapshot/

  ) in

  <proposal_root>/<intermediate_dir>/snapshot/

  first, and use it as

  --src-dir

  to avoid copying

  .nsfc-reviewers/

  ,

  panels/

  and other intermediate/deliverable directories into the

  workspace/

  of each thread again.
• Minimum approach: Copy the "proposal directory to be reviewed" to

  snapshot/

  and exclude intermediate/deliverable directories (specific commands depend on platform tools; principle: the snapshot directory should only contain proposal source files).

python3 <parallel_vibe_path> \
  --plan-file <plan_json_path> \
  --src-dir <proposal_snapshot_root_or_proposal_root> \
  --out-dir <proposal_root>/<intermediate_dir> \
  --timeout-seconds <config:parallel_review.timeout_seconds> \
  --no-synthesize

1. Collect and Verify Panel Outputs:
   • Read

     panel_output_filename

     from the

     workspace/

     of each thread
   • Typical path (after running but before organizing output):

     <proposal_root>/<intermediate_dir>/.parallel_vibe/<project_id>/<thread_id>/workspace/<panel_output_filename>

   • If you have executed "Phase 5: Output Organization", the parallel-vibe environment is usually located at:

     <proposal_root>/<intermediate_dir>/parallel-vibe/<project_id>/...

   • parallel-vibe

     will print the current

     project_root

     path in stdout; prioritize using this path
   • If the output of individual threads is missing, record the missing and continue aggregating completed results (fail-soft)
   • It is recommended to copy/organize the final review report of each panel into final deliverable files:

     <proposal_root>/{panel_dir}/G{thread_id}.md

Single-Group Mode Steps (Degradation)

1. Read

   references/expert_*.md

   to get 5 expert personas (innovation/methodology/foundation/strict/constructive)
2. Simulate parallel process: let 5 experts complete "independent reviews" in sequence (without referencing each other)
3. Perform intra-panel aggregation (consensus identification/severity escalation/deduplication and merging)
4. Output the single-panel review report to

   panel_output_filename

Phase 4: Aggregation, Sorting and Optional Conclusion

Cross-Panel Aggregation (Parallel Multi-Group Mode)

1. Read cross-panel aggregation rules from

   references/aggregation_rules.md

   .
2. Cross-compare N groups of

   panel_review.md

   to identify different expressions of the same issue.
3. Cross-panel consensus threshold: pointed out by at least

   ceil(N * consensus_threshold)

   panels → cross-panel consensus (threshold see

   config.yaml:parallel_review.aggregation.consensus_threshold

   ).
4. Secondary severity escalation: cross-panel consensus issues P2→P1→P0 (P0 no longer escalated).
5. Merge duplicate issues, retaining the most complete evidence anchors and actionable suggestions.
6. Retain independent opinions and label their source panel (e.g., "from Panel G001").
7. Output results in order of P0→P1→P2, and provide a minimal viable modification sequence.
8. If

   keep_individual_reviews == true

   , append original review reports of each panel in the appendix.

Single-Panel Summary

Optional Comprehensive Conclusion

Phase 5: Output Organization (Mandatory Execution)

config.yaml:output_settings.enforce_output_finalization == true

config.yaml:output_settings.intermediate_dir

.nsfc-reviewers/

Pre-Check (Execute in Order)

1. Calculate and confirm

   effective_panel_count

   (see Phase 3).
2. Determine the review mode for this time:
   • If

     effective_panel_count > 1

     and you actually called

     parallel-vibe

     (or found the

     .parallel_vibe/

     runtime environment) → regarded as "parallel mode"
   • Otherwise → "serial mode" (still must create minimal intermediate directories and logs)

Recommended Approach: Use Script to Automate Output Organization (Deterministic, Highly Recommended)

python3 <nsfc_reviewers_path>/scripts/finalize_output.py \
  --review-path <proposal_root> \
  --panel-count <effective_panel_count> \
  --intermediate-dir <config:output_settings.intermediate_dir> \
  --apply

Without

--apply

, it is a DRY-RUN: only print actions to be executed without modifying files.

Manual Organization (Fallback When Script Is Unavailable)

mkdir -p <proposal_root>/<intermediate_dir>/{parallel-vibe,logs/plans,snapshot}

.parallel_vibe/

<intermediate_dir>/parallel-vibe/

# 1) Prioritize migration from <proposal_root>/<intermediate_dir>/.parallel_vibe/ (common when parallel-vibe --out-dir points to intermediate_dir)
if [ -d "<proposal_root>/<intermediate_dir>/.parallel_vibe" ]; then
  mv "<proposal_root>/<intermediate_dir>/.parallel_vibe/"* "<proposal_root>/<intermediate_dir>/parallel-vibe/" 2>/dev/null || true
  rmdir "<proposal_root>/<intermediate_dir>/.parallel_vibe" 2>/dev/null || true
fi

# 2) Compatible with old instances: migrate from root directory .parallel_vibe/
if [ -d "<proposal_root>/.parallel_vibe" ]; then
  mv "<proposal_root>/.parallel_vibe/"* "<proposal_root>/<intermediate_dir>/parallel-vibe/" 2>/dev/null || true
  rmdir "<proposal_root>/.parallel_vibe" 2>/dev/null || true
fi

mv "<proposal_root>/master_prompt.txt" "<proposal_root>/<intermediate_dir>/logs/" 2>/dev/null || true
mv "<proposal_root>"/plan*.json "<proposal_root>/<intermediate_dir>/logs/plans/" 2>/dev/null || true
mv "<proposal_root>/proposal_snapshot" "<proposal_root>/<intermediate_dir>/snapshot/" 2>/dev/null || true

Verification Checklist (Self-Check After Execution, Cannot End If Not Passed)

• <proposal_root>/<intermediate_dir>/

  has been created, and contains at least

  logs/

  and

  logs/plans/

• If in parallel mode:

  <proposal_root>/<intermediate_dir>/parallel-vibe/

  contains the

  <project_id>/...

  runtime environment

• master_prompt.txt

  (or its copy) can be found in

  <proposal_root>/<intermediate_dir>/logs/

• Final deliverables are still in the root directory:

  {default_filename}

  and

  {panel_dir}/G*.md

  (unrelated intermediate files should not be scattered in the root directory)

Report Format (Hard Threshold)

• Evidence Anchor

  : Filename + chapter title/key sentence (line number optional)

• Observation

  : Why this is an issue (no vague descriptions)

• Impact

  : How it will affect review judgment/feasibility/persuasiveness

• Suggestion

  : Actionable modification plan (prioritize providing "how to modify" and "what level of modification is sufficient")

• Validation

  : How to self-check after modification (e.g., "add a roadmap", "add a paragraph of coordinate system comparison", "add a chain of pre-experiment evidence")

# NSFC Proposal Review Opinions (N Groups of Independent Experts)

## Review Configuration
- Number of review panels: N groups
- Experts per panel: 5
- Total expert person-times: N×5

## Cross-Panel Consensus (Pointed Out by Multiple Groups)
### P0 Level

## Independent Opinions (Proposed by Single Group)
### From Panel G001

## Summary of Modification Suggestions

## Appendix: Original Review Reports of Each Panel (Optional)

Usage Example

Please review the NSFC proposal at /path/to/nsfc_proposal and save the opinions to /path/to/output.md

Configuration Parameters

config.yaml

• review_dimensions

  : Review dimension configuration (weights/key points/common issues)

• severity_levels

  : Definition of issue severity levels

• review_grades

  : Review grades and suggestions (optional output)

• proposal_files

  : Proposal file identification rules

• output_settings

  : Output settings (default filename/panel directory/intermediate directory/chapter switches; and output organization verification:

  enforce_output_finalization

  /

  warn_missing_intermediate

  /

  validation_level

  )

• parallel_review

  : Parallel multi-group review configuration (switch/number of panels/expert persona references/cross-panel aggregation strategy)