@research-copilot/plugin 1.1.16 → 1.1.18

package/dist/skills/vibe-research-workflow/references/behavior-guidelines.md

@@ -0,0 +1,149 @@
+# Behavioural guidelines for Vibe Research
+
+## Table of contents
+
+1. Why rules are needed
+2. Rule 1: Permitted AI uses
+3. Rule 2: Owned by the user
+4. Rule 3: Verify every AI output
+5. Rule 4: No fabricated citations
+6. Rule 5: No academic misconduct
+7. Rule 6: Honour venue disclosure rules
+8. Compliance examples
+9. Non-compliance examples
+
+## 1. Why rules are needed
+
+AI tools accelerate routine work, but they cannot own a research
+contribution. Without explicit rules, the boundary between "AI
+helped me" and "AI did my work" blurs. The six rules below are the
+group's working contract: they enable productive AI use while
+preserving the researcher's ownership and the group's integrity.
+
+The rules are not preferences. Violations risk academic
+misconduct findings, paper retractions, and career consequences.
+
+## 2. Rule 1: Permitted AI uses
+
+Allowed uses of AI tools, including LLMs:
+
+- Literature search and organisation: retrieving papers,
+  summarising related work for the user's own reading, managing
+  bibliography files.
+- Code support and debugging: generating scaffolding, explaining
+  compiler errors, proposing refactors.
+- Language and expression polish: grammar correction, phrasing
+  suggestions, paragraph restructuring for flow.
+
+All of these are mechanical acceleration. None of them replace
+the user's scientific judgment.
+
+## 3. Rule 2: Owned by the user
+
+The following must be the user's own work and must be fully
+understood by the user:
+
+- Research ideas.
+- Research problems and framings.
+- Research design.
+- Technical pathways and algorithmic choices.
+- Experimental plans.
+- Core conclusions.
+- Novelty claims.
+
+AI can ask clarifying questions; AI can point out overlooked
+options; AI cannot make these decisions. If the user cannot
+explain a design choice without referring to what AI said, the
+user does not own it.
+
+## 4. Rule 3: Verify every AI output
+
+Every AI-generated or AI-assisted passage requires user
+verification:
+
+- Code must be read, understood, and tested.
+- Prose must be cross-checked against the research process and
+  experimental results; no discrepancies or exaggerations.
+- Numerical claims must be traced back to experiment outputs.
+
+Verification is sentence-by-sentence for prose and line-by-line
+for code. Spot-checking is insufficient.
+
+## 5. Rule 4: No fabricated citations
+
+Citations must come from the user's own literature search,
+reading, and confirmation. AI must never:
+
+- Invent paper titles, authors, or venues.
+- Generate BibTeX entries for papers that do not exist.
+- Cite a paper the user has not read.
+
+When AI proposes a citation, the user must:
+
+1. Find the paper in a scholarly source (Google Scholar, DBLP,
+   arXiv).
+2. Read at least the abstract.
+3. Confirm the claim the user is making matches the paper's
+   actual content.
+
+If any of these fail, the citation is removed.
+
+## 6. Rule 5: No academic misconduct
+
+Never use AI to:
+
+- Generate fake data or experimental results.
+- Fabricate, alter, or invent experimental procedures.
+- Hide or paraphrase plagiarism from prior work.
+- Rewrite another group's results as the user's own.
+
+Academic misconduct, whether AI-assisted or not, is a career-
+ending line. AI-assisted misconduct is not less serious; if
+anything, it is easier to detect (AI-generated fake data often
+has statistical signatures).
+
+## 7. Rule 6: Honour venue disclosure rules
+
+Many conferences, journals, and schools have explicit AI
+disclosure or usage rules for paper submissions and theses. These
+rules are evolving and vary widely:
+
+- Some require disclosure of AI-assisted drafting.
+- Some forbid AI-generated content in specific sections.
+- Some require attestation that the author wrote the submitted
+  text.
+
+The user's responsibility:
+
+- Check the target venue's current policy before submission.
+- Consult the advisor when in doubt.
+- Disclose AI usage in the paper or submission form as
+  required.
+- Comply with institutional policies as well as venue policies.
+
+## 8. Compliance examples
+
+- "I used Cursor to scaffold the training loop; I wrote all the
+  loss functions and verified each gradient by hand." Compliant.
+- "Claude suggested three ways to structure the Introduction; I
+  picked one, rewrote it in my own words, and confirmed it
+  matches my actual contribution." Compliant.
+- "ChatGPT corrected grammar in my Abstract; I read the changes
+  line by line and re-verified that each claim is in my paper."
+  Compliant.
+
+## 9. Non-compliance examples
+
+- "I asked Claude to write the entire Related Work section and
+  inserted the output." Non-compliant (rule 2, 3).
+- "ChatGPT gave me five citations that looked plausible; I added
+  them to my bibliography." Non-compliant (rule 4).
+- "I let the AI generate missing data points for the figure
+  because the experiment did not quite work." Non-compliant
+  (rule 5; this is a career-ending violation).
+- "The submission form asks whether I used AI; I said no because
+  I only used it for grammar." Non-compliant (rule 6; disclose
+  honestly or follow the venue's definition).
+- "My advisor said I should write everything myself; I used AI
+  only for the final polish without telling them." Non-compliant
+  (rule 2, 6).

package/dist/skills/vibe-research-workflow/references/tool-selection.md

@@ -0,0 +1,144 @@
+# Tool selection for Vibe Research
+
+## Table of contents
+
+1. Selection heuristic
+2. Vibe Coding tools
+3. Vibe Figure tools
+4. Vibe Writing tools
+5. Cost considerations
+6. Access from mainland China
+
+## 1. Selection heuristic
+
+Pick the tool that matches the phase, not the other way around.
+
+| Phase | Primary tool | Alternative | When |
+|---|---|---|---|
+| Coding (IDE-native) | Cursor | VS Code + GitHub Copilot | User wants to stay in a VS Code-compatible editor |
+| Coding (agentic CLI) | Claude Code | Codex | User prefers CLI, rich Skills ecosystem |
+| Coding (cloud-integrated) | Codex | Cursor | User wants GitHub-integrated cloud workflows |
+| Figure (conceptual sketch) | Gemini or Nano Banana | Hand-drawn plus photo | Early exploration |
+| Figure (final Figure 1) | PowerPoint then Figma | OmniGraffle (macOS) | Paper-ready |
+| Figure (experimental charts) | Matplotlib + Seaborn | TikZ + PGFPlots | Reproducible scientific plots |
+| Writing (polish) | Claude | ChatGPT, Gemini | Long-form polish with context preservation |
+| Writing (grammar) | Grammarly | LanguageTool | Final pass on mechanical grammar |
+
+## 2. Vibe Coding tools
+
+### Cursor
+
+- VS Code-based AI-native editor.
+- Low adoption cost for VS Code users.
+- Pro plan 20 USD per month.
+- Plan Mode plus Agent Mode separation is valuable.
+- Recommended HTTP Compatibility Mode setting: HTTP 1.1.
+
+### Claude Code
+
+- CLI and desktop agentic coding tool by Anthropic.
+- Steeper entry curve; rewards investment with rich Skills and
+  MCP ecosystem.
+- Works well for extended autonomous sessions.
+
+### Codex
+
+- OpenAI agentic coding tool with CLI and desktop.
+- Strong GitHub integration and cloud environment support.
+- 20 USD per month floor.
+- No in-editor code surface; works through the CLI or desktop
+  app.
+
+### Tool-specific tips
+
+For Cursor: enable Plan Mode for any non-trivial task. Toggle
+with Shift+Tab.
+
+For Claude Code: install relevant Skills (from marketplaces or
+local) before starting. `ralph-loop`, `writing-skills`, and
+`debugging` are frequently useful.
+
+For Codex: use the cloud environment for heavier tasks;
+configure repository access via GitHub.
+
+## 3. Vibe Figure tools
+
+### Conceptual sketches
+
+- Gemini can produce rough visual concepts given a description.
+- Nano Banana is useful for quick layout exploration.
+- Hand-drawing on paper remains the fastest concept tool.
+
+### Layout and polish
+
+- PowerPoint: fastest iteration for Motivated Example; exports
+  to PDF as vector.
+- Figma: cleanest polish; component reuse; browser-based.
+- OmniGraffle: professional diagram quality on macOS; paid.
+- draw.io: free, offline, good for pipelines and architectures.
+
+### Experimental charts
+
+- Matplotlib plus Seaborn: reproducible, scriptable, versioned.
+- TikZ plus PGFPlots: LaTeX-integrated; steep learning curve;
+  best for final camera-ready.
+- Plotly: interactive, useful in supplementary materials.
+
+## 4. Vibe Writing tools
+
+### Polish
+
+- Claude: long context, preserves technical detail reliably.
+- ChatGPT: strong at style suggestions; be careful of AI-tone
+  drift.
+- Gemini: free tier is usable for light polish.
+
+### Grammar
+
+- Grammarly: integrates with Overleaf as a browser extension.
+- LanguageTool: open-source alternative.
+- Overleaf built-in: basic grammar and spell-check.
+
+### LaTeX
+
+- Overleaf: cloud-based LaTeX with collaboration.
+- Local LaTeX: preferred when the paper is under heavy
+  revision or when internet access is unstable.
+
+## 5. Cost considerations
+
+Minimal monthly cost for a serious Vibe Research setup:
+
+- 20 USD for one coding assistant (Cursor or Codex or Claude
+  Code).
+- 0 to 20 USD for writing polish (many options at zero).
+- 0 to 10 USD for figure tools (most free; Figma Pro optional).
+
+Total: roughly 20 to 50 USD per month. Lab or institutional
+subscriptions often cover this.
+
+Watch for:
+
+- Inference-quota limits during high-load weeks (deadline
+  crunches often trigger throttling).
+- Pay-per-token costs in API-based flows; cap via dashboard
+  budgets.
+
+## 6. Access from mainland China
+
+Researchers in mainland China face additional access constraints
+for OpenAI and Anthropic endpoints. Options:
+
+- Proxy services (ensure OpenAI and Google requests are
+  correctly forwarded; check latency).
+- Lab OpenAI-compatible endpoints (the group's
+  hk.yi-zhan.top and vip.yi-zhan.top serve this purpose).
+- Cursor Pro with proxy setup.
+- Local models for offline development when cloud is
+  unavailable.
+
+Network stability is itself a tool-selection factor: unstable
+network favours tools that degrade gracefully (Cursor's local
+model option, local Matplotlib) over tools that require
+continuous cloud access (fully agentic CLIs during long
+sessions).

package/dist/skills/vibe-research-workflow/references/vibe-coding.md

@@ -0,0 +1,154 @@
+# Vibe Coding: mindset and techniques
+
+## Table of contents
+
+1. Core shift: from Coder to Commander
+2. Mindset (心法): six principles
+3. Technique 1: Plan Before Execute
+4. Technique 2: Clear Requirements
+5. Technique 3: Small Steps
+6. Technique 4: Context Management
+7. Technique 5: Error Handling
+8. Technique 6: Git Discipline
+
+## 1. Core shift: from Coder to Commander
+
+What changes:
+
+| Old role | New role |
+|---|---|
+| Memorise syntax rules | Describe requirements clearly |
+| Hand-write code | Judge whether code is correct |
+| Debug manually | Describe the problem and ask AI to fix |
+| Read technical documentation | Know what to ask and what to look up |
+
+What stays the same:
+
+- The user must know what they want.
+- The user must judge whether results are good.
+- The user must have problem-solving intuition.
+
+Without these, AI-assisted coding accelerates mistakes.
+
+## 2. Mindset (心法): six principles
+
+- **Do what AI cannot, delegate what AI can**.
+- **Ask AI first**.
+- **Purpose-driven**: every action in the development process
+  serves a specific purpose.
+- **Context is king**: context quality determines AI output
+  quality. Garbage in, garbage out.
+- **Occam's razor**: do not add unnecessary code; less irrelevant
+  context keeps AI focused.
+- **Subtractive MVP thinking**: minimum visible product. Validate
+  the core assumption with the smallest effort, then expand.
+
+## 3. Technique 1: Plan Before Execute
+
+For Cursor, use Plan Mode (Shift+Tab toggle) before switching to
+Agent Mode. For Claude Code, ask for a plan explicitly before
+allowing implementation.
+
+Value:
+
+- Confirm AI understands the goal, the implementation, and the
+  objective.
+- Detect misinterpretation early rather than after hundreds of
+  wasted lines.
+- Let the user evaluate the planned approach before code runs.
+
+When plan and goal diverge, the plan is wrong and the user
+corrects before execution, not after.
+
+## 4. Technique 2: Clear Requirements
+
+Clear requirements mean less rework and fewer bugs.
+
+For each code task, specify:
+
+- What functionality is needed.
+- Inputs and outputs (types, formats, sample values).
+- Style or framework constraints (for example, use the official
+  OpenAI SDK rather than LangChain, parallelise where possible).
+- What the task does not include (to prevent scope creep).
+
+Template:
+
+```
+I want to implement <module name>. It does <function description>.
+Input: <format and structure>.
+Output: <format and structure>.
+
+Constraints:
+- ...
+- ...
+
+Non-requirements:
+- ...
+```
+
+## 5. Technique 3: Small Steps
+
+Break the task into the smallest verifiable units. For each unit:
+
+- Write a one-paragraph requirement.
+- Have AI implement it.
+- Run it.
+- Verify the output.
+- Commit.
+- Move to the next unit.
+
+Large monolithic asks (make the whole system) produce brittle
+output. Small verified steps compound into working systems.
+
+## 6. Technique 4: Context Management
+
+Context is the set of files, documentation, and conversation
+history the AI sees when producing its response.
+
+Good context management:
+
+- Load only relevant files into the conversation. Do not dump an
+  entire repository.
+- When switching topics, start a new conversation.
+- Feed AI the exact error messages and stack traces when
+  debugging.
+- Avoid loading auto-generated files (compiled code, caches) into
+  the context.
+
+Bad context management:
+
+- Leaving dozens of unrelated files attached.
+- Switching topics without clearing context, so AI conflates
+  unrelated requests.
+- Pasting Markdown tables without the schema AI needs to
+  interpret them.
+
+## 7. Technique 5: Error Handling
+
+When AI-generated code fails:
+
+- Run the code first, capture the full error output, paste the
+  error message back to AI with context ("this was the code, this
+  was the error").
+- Do not assume AI knows; explicit trumps implicit.
+- If AI patches incorrectly, describe the actual symptom
+  precisely.
+- For persistent failures (three tries), step back and re-plan.
+  Loop spirals are a signal that the plan is wrong.
+
+## 8. Technique 6: Git Discipline
+
+AI-assisted coding produces a higher rate of bad commits than
+hand-written code. Git discipline catches this.
+
+- Commit frequently (project memory
+  `feedback_git_versioning`); each small verified unit is a
+  commit.
+- Run the code before committing.
+- Use meaningful commit messages; do not accept AI's suggestion
+  if it obscures the change.
+- Never push AI-generated code without testing; "it compiles" is
+  not a test.
+- Rollback is cheap; use it when AI-generated changes break
+  things. A bad AI commit rarely rewards being salvaged.

package/dist/skills/vibe-research-workflow/references/vibe-figure.md

@@ -0,0 +1,131 @@
+# Vibe Figure: four-step workflow
+
+## Table of contents
+
+1. Why Vibe Figure works
+2. Step 1: Discuss with AI
+3. Step 2: Select and prompt
+4. Step 3: Generate first sketch
+5. Step 4: Vectorise by hand
+6. What AI cannot do
+7. Integration with figure-designer
+
+## 1. Why Vibe Figure works
+
+Figures combine conceptual design (what to show) with craft (how
+to render it cleanly). AI helps most on conceptual brainstorming
+and first-draft layouts; craft still belongs to the user plus
+their vector-graphics tool of choice.
+
+The four-step workflow separates the AI-accelerated phases from
+the hand-polished phases.
+
+## 2. Step 1: Discuss with AI
+
+Before drawing anything, describe the figure's purpose to the AI
+and ask for design alternatives.
+
+Prompt template:
+
+```
+I'm designing Figure 1 for a paper on <topic>.
+The figure should communicate <the single message>.
+The figure appears in <section, position>.
+Target venue: <name>, two-column format.
+
+Please propose three layout alternatives. For each, describe:
+- Panel structure
+- Colour use
+- Key annotations
+- Tradeoffs compared with the other alternatives
+```
+
+AI returns three alternatives; the user discusses with an advisor
+or collaborator; the best alternative is chosen.
+
+## 3. Step 2: Select and prompt
+
+Given the selected alternative, refine the prompt with specific
+details.
+
+Prompt refinement:
+
+- Specific entity names (real queries, real datasets, not
+  placeholders).
+- Concrete failure or success indicators (exact wrong output
+  versus correct output).
+- Colour specifics (Ours in a specific ColorBrewer index;
+  baselines in grey).
+- Annotations with concrete text.
+- Canvas dimensions targeting the paper's column width.
+
+Avoid:
+
+- Vague requests ("make it look professional").
+- Asking for things the tool cannot produce (AI sketch tools
+  cannot produce Matplotlib-quality scientific charts).
+- Letting AI invent data; data comes from the user's experiments.
+
+## 4. Step 3: Generate first sketch
+
+Tool choice by figure type:
+
+- Motivated Example (Figure 1): Gemini with Nano Banana or a
+  similar tool can produce first sketches of conceptual figures.
+  The output is a visual reference, not a paper-ready figure.
+- Solution Overview: draw.io, Excalidraw, or hand-sketching on
+  paper, then photographed and iterated.
+- Experimental Results: Matplotlib prototypes run by the user
+  from experiment output; AI scaffolds the `plot_utils.py`
+  helper.
+
+The first sketch is diagnostic, not final. It answers "does the
+design work visually?" Not "is this ready for the paper?"
+
+## 5. Step 4: Vectorise by hand
+
+Take the first sketch and produce the final paper-ready figure
+by hand in a vector tool:
+
+- Motivated Example and Solution Overview: PowerPoint (draft) or
+  Figma (polish). Do not trust AI sketches as final; they lack
+  typographic discipline.
+- Experimental Results: Matplotlib or Seaborn scripted from the
+  actual experiment outputs. The script lives in the repository
+  and regenerates on data updates.
+
+Quality control (see `figure-designer`'s `design-rules.md`):
+
+- Vector format export.
+- Font size at least 8pt post-scaling.
+- Colour-blind-safe palette, dual encoding.
+- Self-contained caption.
+- No chartjunk.
+
+## 6. What AI cannot do
+
+AI-generated figures in their current state cannot:
+
+- Produce paper-quality scientific charts with correct
+  statistical conventions.
+- Generate vector output that is editable at the object level.
+- Maintain visual consistency across a paper's figure set.
+- Guarantee correct annotation of data points or entities.
+- Handle typography at the level expected for academic figures.
+
+Plan for AI-assistance in ideation and drafting, not in final
+production. Every final figure is the user's work.
+
+## 7. Integration with figure-designer
+
+This skill orchestrates the workflow; `figure-designer` handles
+the individual figure design decision.
+
+Typical sequence:
+
+1. `vibe-research-workflow` (this skill, figure-mode): plan the
+   figure-production session.
+2. `figure-designer`: for each figure, decide paradigm, layout,
+   labelling, tool, and run the audit.
+3. Execute the four-step flow above for each figure.
+4. Integrate back into the paper.