@research-copilot/plugin 1.1.17 → 1.1.19

package/dist/skills/proof-writer/SKILL.md

@@ -0,0 +1,222 @@
+---
+name: "proof-writer"
+description: "Writes rigorous mathematical proofs for ML/AI theory. Use when asked to prove a theorem, lemma, proposition, or corollary, fill in missing proof steps, formalize a proof sketch, \u8865\u5168\u8bc1\u660e, \u5199\u8bc1\u660e, \u8bc1\u660e\u67d0\u4e2a\u547d\u9898, or determine whether a claimed proof can actually be completed under the stated assumptions."
+---
+
+# Proof Write: Rigorous Theorem / Lemma Drafting
+
+Write a mathematically honest proof package, not a polished fake proof.
+
+## Constants
+
+- DEFAULT_PROOF_DOC = `PROOF_PACKAGE.md` in project root
+- STATUS = `PROVABLE AS STATED | PROVABLE AFTER WEAKENING / EXTRA ASSUMPTION | NOT CURRENTLY JUSTIFIED`
+
+## Context: $ARGUMENTS
+
+## Goal
+
+Produce exactly one of:
+1. a complete proof of the original claim
+2. a corrected claim plus a proof of the corrected claim
+3. a blockage report explaining why the claim is not currently justified
+
+## Inputs
+
+Extract and normalize:
+- exact theorem / lemma / proposition / corollary statement
+- explicit assumptions
+- notation and definitions
+- any user-provided proof sketch, partial proof, or intended strategy
+- nearby lemmas or claims in local notes, appendix files, or theorem drafts if the request points to them
+- desired output style if specified: concise, appendix-ready, or full-detail
+
+If notation or assumptions are ambiguous, state the exact interpretation you are using before proving anything.
+
+## Workflow
+
+### Step 1: Gather Proof Context
+Determine the target proof file with this priority:
+1. a file path explicitly specified by the user
+2. a proof draft already referenced in local notes or theorem files
+3. `PROOF_PACKAGE.md` in project root as the default target
+
+Read the relevant local context:
+- the chosen target proof file, if it already exists
+- theorem notes, appendix drafts, or files explicitly mentioned by the user
+
+Extract:
+- exact claim
+- assumptions
+- notation
+- proof sketch or partial proof
+- nearby lemmas that the draft may depend on
+
+### Step 2: Normalize the Claim
+Restate:
+- the exact claim being proved
+- all assumptions, separately from conclusions
+- all symbols used in the claim
+
+Identify:
+- hidden assumptions
+- undefined notation
+- scope ambiguities
+- whether the available sketch proves the full claim or only a weaker variant
+
+Preserve the user's original theorem statement unless a change is explicitly required.
+If you use a stronger normalization or cleaner internal formulation only to make the proof easier, keep that as an internal proof device rather than silently replacing the original claim.
+
+### Step 3: Feasibility Triage
+Before writing a proof, classify the claim into exactly one status:
+- `PROVABLE AS STATED`
+- `PROVABLE AFTER WEAKENING / EXTRA ASSUMPTION`
+- `NOT CURRENTLY JUSTIFIED`
+
+Check explicitly:
+- does the conclusion actually follow from the listed assumptions?
+- is any cited theorem being used outside its conditions?
+- is the claim stronger than what the available argument supports?
+- is there an obvious counterexample, boundary case, or quantifier failure?
+
+If the claim is not provable as stated, do NOT fabricate a proof.
+Do NOT silently strengthen assumptions or narrow the theorem's scope just to make the proof work.
+
+### Step 4: Build a Dependency Map
+Choose a proof strategy, for example:
+- direct
+- contradiction
+- induction
+- construction
+- reduction to a known result
+- coupling / probabilistic argument
+- optimization inequality chaining
+
+Then write a dependency map:
+- main claim
+- required intermediate lemmas
+- named theorems or inequalities that will be cited
+- which assumptions each nontrivial step depends on
+- boundary cases that must be handled separately
+
+If one step is substantial, isolate it as a lemma instead of burying it in one sentence.
+
+### Step 5: Write the Proof Document
+Write to the chosen target proof file.
+
+If the target proof file already exists:
+- read it first
+- update the relevant claim section
+- do not blindly duplicate prior content
+
+If the user does not specify a target, default to `PROOF_PACKAGE.md` in project root.
+
+Do NOT write directly into paper sections or appendix `.tex` files unless the user explicitly asks for that target.
+
+The proof package must include:
+- exact claim
+- explicit assumptions
+- proof status
+- announced strategy
+- dependency map
+- numbered major steps
+- justification for every nontrivial implication
+
+Mathematical rigor requirements:
+- never use "clearly", "obviously", "it can be shown", "by standard arguments", or "similarly" to hide a gap
+- define every constant and symbol before use
+- check quantifier order carefully
+- handle degenerate and boundary cases explicitly, or state why they are excluded
+- if invoking a standard fact, state its name and why its assumptions are satisfied here
+- use `$...$` for inline math and `$$...$$` for display equations
+- never write math in plain text
+- if the proof uses an equivalent normalization that is stronger in appearance than the user's original theorem statement, label it explicitly as a proof device and keep the original claim separate
+
+### Step 6: Final Verification
+Before finishing the target proof file, verify:
+- the theorem statement exactly matches what was actually shown
+- every assumption used is stated
+- every nontrivial implication is justified
+- every inequality direction is correct
+- every cited result is applicable under the stated assumptions
+- edge cases are handled or explicitly excluded
+- no hidden dependence on an unproved lemma remains
+
+If a key step still cannot be justified, downgrade the status and write a blockage report instead of forcing a proof.
+
+## Required File Structure
+
+Write the target proof file using this structure:
+
+```md
+# Proof Package
+
+## Claim
+[exact statement]
+
+## Status
+PROVABLE AS STATED / PROVABLE AFTER WEAKENING / NOT CURRENTLY JUSTIFIED
+
+## Assumptions
+- ...
+
+## Notation
+- ...
+
+## Proof Strategy
+[chosen approach and why]
+
+## Dependency Map
+1. Main claim depends on ...
+2. Lemma A depends on ...
+3. Step k uses ...
+
+## Proof
+Step 1. ...
+Step 2. ...
+...
+Therefore the claim follows. ∎
+
+## Corrections or Missing Assumptions
+- [only if needed]
+
+## Open Risks
+- [remaining fragile points, if any]
+```
+
+## Output Modes
+
+### If the claim is provable as stated
+Write the full file structure above with a complete proof.
+
+### If the original claim is too strong
+Write:
+- why the original statement is not justified
+- the corrected claim
+- the minimal extra assumption if one exists
+- a proof of the corrected claim
+
+### If the proof cannot be completed honestly
+Write:
+- `Status: NOT CURRENTLY JUSTIFIED`
+- the exact blocker: missing lemma, invalid implication, hidden assumption, or counterexample direction
+- what extra assumption, lemma, or derivation would be needed to finish the proof
+- a corrected weaker statement if one is available
+
+## Chat Response
+
+After writing the target proof file, respond briefly with:
+- status
+- whether the original claim survived unchanged
+- what file was updated
+
+## Key Rules
+
+- Never fabricate a missing proof step.
+- Prefer weakening the claim over overclaiming.
+- Separate assumptions, derived facts, heuristics, and conjectures.
+- Preserve the user's original theorem statement unless you explicitly mark a corrected claim or an internal normalization.
+- If the statement is false as written, say so explicitly and give a counterexample or repaired statement.
+- If uncertainty remains, mark it explicitly in `Open Risks`; do not hide it inside polished prose.
+- Correctness matters more than brevity.
+

package/dist/skills/qzcli/SKILL.md

@@ -0,0 +1,316 @@
+---
+name: qzcli
+description: Manage GPU compute jobs on the Qizhi (启智) platform using qzcli — a kubectl-style CLI tool. Use when user says "qzcli", "启智平台", "submit job", "stop job", "查计算组", "avail", "list jobs", "batch submit", or needs to manage distributed training jobs on a Qizhi instance.
+argument-hint: [login|avail|list|create|stop <job-id>|batch|status|watch]
+allowed-tools: Bash(*), Read, Write
+---
+
+# qzcli — 启智平台任务管理
+
+A kubectl/docker-style CLI for managing GPU compute jobs on the Qizhi (启智) platform.
+
+**GitHub:** [tianyilt/qzcli_tool](https://github.com/tianyilt/qzcli_tool)
+
+## Installation
+
+```bash
+pip install rich requests prompt_toolkit mcp
+git clone https://github.com/tianyilt/qzcli_tool
+cd qzcli_tool && pip install -e .
+```
+
+### MCP Integration (optional)
+
+To use qzcli as an MCP tool directly from Claude Code or Codex:
+
+```bash
+# Claude Code
+claude mcp add qzcli -- qzcli-mcp
+
+# Codex
+codex mcp add qzcli -- qzcli-mcp
+```
+
+---
+
+## Configuration
+
+Credentials are read in this priority order:
+`CLI args > --password-stdin > env vars > QZCLI_ENV_FILE (.env) > ~/.qzcli/config.json > interactive input`
+
+```bash
+# Option A: env file (recommended)
+mkdir -p ~/.qzcli
+cat > ~/.qzcli/.env <<'EOF'
+QZCLI_USERNAME="your_username"
+QZCLI_PASSWORD="your_password"
+EOF
+
+# Option B: environment variables
+export QZCLI_USERNAME="your_username"
+export QZCLI_PASSWORD="your_password"
+export QZCLI_API_URL="https://qz.yourorg.edu.cn"
+```
+
+Config files are stored in `~/.qzcli/`: `config.json`, `.cookie`, `resources.json`, `jobs.json`.
+
+---
+
+## Quick Start
+
+```bash
+# 1. Login
+qzcli login
+
+# 2. Discover and cache workspaces/compute groups (run once, re-run after joining new workspaces)
+qzcli res -u
+
+# 3. Check available nodes
+qzcli avail
+
+# 4. List running jobs
+qzcli ls -c -r
+```
+
+---
+
+## Authentication
+
+```bash
+# Interactive login
+qzcli login
+
+# With credentials
+qzcli login -u YOUR_USERNAME -p 'YOUR_PASSWORD'
+
+# Read password from stdin (for scripts)
+echo 'YOUR_PASSWORD' | qzcli login -u YOUR_USERNAME --password-stdin
+
+# Check current cookie
+qzcli cookie --show
+
+# Clear cookie
+qzcli cookie --clear
+```
+
+**Note:** `qzcli avail` auto-refreshes the cookie if it expires and credentials are configured.
+
+---
+
+## Resource Discovery
+
+```bash
+# List cached workspaces
+qzcli res --list
+
+# Refresh all workspace resource cache (run this first!)
+qzcli res -u
+
+# Refresh a specific workspace
+qzcli res -w MY_WORKSPACE -u
+
+# Set a human-readable alias for a workspace
+qzcli res -w ws-xxxxxxxx --name "My Workspace"
+```
+
+---
+
+## Check Available Nodes
+
+```bash
+# All workspaces
+qzcli avail
+
+# Including low-priority task nodes (slower but more accurate)
+qzcli avail --lp
+
+# Specific workspace
+qzcli avail -w MY_WORKSPACE
+
+# Find compute groups with N free nodes
+qzcli avail -n 4
+
+# Export IDs for scripting
+qzcli avail -n 4 -e
+
+# Show idle node names
+qzcli avail -w MY_WORKSPACE -v
+```
+
+---
+
+## Job Submission
+
+### Interactive (recommended for first-time use)
+
+```bash
+# Full interactive selection: workspace → project → compute group → spec
+qzcli create -i
+
+# Interactive for a specific workspace only
+qzcli create -i -w "My Workspace"
+```
+
+The TUI shows GPU type, availability, and spec status at each level. Press `Enter/→` to go deeper, `←` to go back.
+
+### Non-interactive
+
+```bash
+# Using names (resolved from qzcli res cache)
+qzcli create \
+  --name "my-training-job" \
+  --command "bash /path/to/train.sh" \
+  --workspace "My Workspace" \
+  --compute-group "My Compute Group" \
+  --image YOUR_REGISTRY/team/image:tag \
+  --instances 4 \
+  --priority 10
+
+# Using IDs directly
+qzcli create \
+  --name "my-job" \
+  --command "bash /path/to/train.sh" \
+  --workspace ws-YOUR_WORKSPACE_ID \
+  --compute-group lcg-YOUR_LCG_ID \
+  --spec YOUR_SPEC_ID \
+  --image YOUR_REGISTRY/team/image:tag \
+  --instances 4
+```
+
+**Key parameters:**
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `--name` / `-n` | required | Job name |
+| `--command` / `-c` | required | Command to run |
+| `--workspace` / `-w` | | Workspace name or ID (`ws-...`) |
+| `--compute-group` / `-g` | auto | Compute group name or ID (`lcg-...`) |
+| `--spec` / `-s` | auto | Resource spec ID |
+| `--image` / `-m` | | Docker image |
+| `--instances` | 1 | Number of instances |
+| `--shm` | 1200 | Shared memory (GiB) |
+| `--priority` | 10 | Priority (1–10) |
+| `--dry-run` | | Preview only, don't submit |
+| `--json` | | JSON output for scripting |
+
+```bash
+# Preview before submitting
+qzcli create --name test --command "echo hi" --workspace "My Workspace" \
+  --image YOUR_IMAGE --dry-run
+```
+
+### Env-var passthrough (for existing submission scripts)
+
+```bash
+# Pass vars directly — do NOT use "export VAR; bash script.sh"
+WORKSPACE_ID="ws-YOUR_WORKSPACE_ID" \
+LCG_ID="lcg-YOUR_LCG_ID" \
+SPEC_ID="YOUR_SPEC_ID" \
+CHECKPOINT_DIR="/path/to/checkpoint" \
+bash YOUR_SUBMIT_SCRIPT.sh
+```
+
+### HPC / CPU jobs (Slurm)
+
+```bash
+qzcli hpc \
+  --name "my-cpu-job" \
+  --workspace ws-YOUR_WORKSPACE_ID \
+  --compute-group lcg-YOUR_LCG_ID \
+  --predef-quota-id YOUR_QUOTA_ID \
+  --cpu 55 --mem-gi 300 --instances 30 \
+  --image YOUR_REGISTRY/team/cpu-image:tag \
+  --entrypoint "cd /path/to/dir && bash run.sh"
+```
+
+---
+
+## Batch Submission
+
+```bash
+# Submit from config file
+qzcli batch batch_config.json --delay 3
+
+# Preview all jobs
+qzcli batch batch_config.json --dry-run
+
+# Continue on error
+qzcli batch batch_config.json --continue-on-error
+```
+
+**Config format** (`batch_config.json`):
+
+```json
+{
+  "defaults": {
+    "workspace": "ws-YOUR_WORKSPACE_ID",
+    "compute_group": "lcg-YOUR_LCG_ID",
+    "spec": "YOUR_SPEC_ID",
+    "image": "YOUR_REGISTRY/team/image:tag",
+    "instances": 4,
+    "priority": 10
+  },
+  "matrix": {
+    "checkpoint": ["/path/to/ckpt1", "/path/to/ckpt2"],
+    "step": [50000, 100000]
+  },
+  "name_template": "eval-{checkpoint_basename}-step{step}",
+  "command_template": "bash eval.sh --checkpoint {checkpoint} --step {step}"
+}
+```
+
+Matrix keys are Cartesian-producted (2×2 = 4 jobs above). Use `{key_basename}` for path basenames.
+
+### Shell loop (alternative)
+
+```bash
+for step in 040000 050000 060000; do
+  qzcli create \
+    --name "eval-step${step}" \
+    --command "bash eval.sh --step $step" \
+    --workspace "My Workspace" \
+    --compute-group "My Compute Group" \
+    --instances 4
+  sleep 3
+done
+```
+
+---
+
+## Job Management
+
+```bash
+# List jobs
+qzcli ls -c -w MY_WORKSPACE          # specific workspace
+qzcli ls -c --all-ws                 # all workspaces
+qzcli ls -c -w MY_WORKSPACE -r       # running only
+qzcli ls -c -w MY_WORKSPACE -n 50    # show 50
+
+# Stop a job
+qzcli stop JOB_ID
+
+# Job status / details
+qzcli status JOB_ID
+
+# Watch all running jobs (refresh every 10s)
+qzcli watch -i 10
+
+# Workspace view with GPU utilization
+qzcli ws
+qzcli ws -a           # all projects
+qzcli ws -p "My Project"
+```
+
+---
+
+## Troubleshooting
+
+| Problem | Cause | Fix |
+|---------|-------|-----|
+| Cookie expired | Session gap | Re-run `qzcli login` |
+| `未找到名称为 'xxx' 的工作空间` | Stale cache | Run `qzcli res -u` |
+| No resources in `create -i` | Cache empty | Run `qzcli login && qzcli res -u` |
+| `qzcli-mcp` not found | Not installed | `cd qzcli_tool && pip install -e .` |
+| Spec not in workspace | ID mismatch | Match spec ID to the correct workspace |
+| Silent job failure | Script `sys.exit(0)` | Check job logs directly |
+| zsh glob errors | Remote shell is zsh | Wrap commands in `bash -c` or use Python |