@research-copilot/plugin 1.1.15 → 1.1.16

package/dist/hooks/tests/test_copilot_write_guard.py

@@ -0,0 +1,137 @@
+"""Tests for copilot_write_guard.py (PreToolUse, Rule 2)."""
+from __future__ import annotations
+
+import json
+from io import StringIO
+from pathlib import Path
+
+import pytest
+
+import copilot_write_guard as guard
+import _copilot_hook_lib as lib
+
+
+def _run(monkeypatch, payload: dict, workspace: Path) -> dict:
+    monkeypatch.setattr("sys.stdin", StringIO(json.dumps(payload)))
+    monkeypatch.chdir(workspace)
+    out = StringIO()
+    monkeypatch.setattr("sys.stdout", out)
+    guard.real_main()
+    return json.loads(out.getvalue().strip().splitlines()[-1])
+
+
+class TestScope:
+    def test_main_agent_allowed(self, monkeypatch, workspace, fixtures_dir, payload_builder):
+        p = payload_builder("Write",
+                            {"file_path": str(workspace / ".copilot" / "state.md")},
+                            str(fixtures_dir / "transcript_main_only.jsonl"))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+    def test_unknown_agent_allowed(self, monkeypatch, workspace, tmp_path, payload_builder):
+        t = tmp_path / "trans.jsonl"
+        t.write_text('{"role":"assistant","metadata":{"subagent_type":"general-purpose"}}\n')
+        p = payload_builder("Write",
+                            {"file_path": str(workspace / ".copilot" / "state.md")},
+                            str(t))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+
+class TestOwnedAllow:
+    def test_literature_writes_own(self, monkeypatch, workspace, fixtures_dir, payload_builder):
+        p = payload_builder("Write",
+                            {"file_path": str(workspace / ".copilot" / "literature.md")},
+                            str(fixtures_dir / "transcript_copilot_literature.jsonl"))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+    def test_unrelated_scratch_allowed(self, monkeypatch, workspace, fixtures_dir, payload_builder):
+        p = payload_builder("Write",
+                            {"file_path": str(workspace / "scratch" / "note.txt")},
+                            str(fixtures_dir / "transcript_copilot_literature.jsonl"))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+
+class TestForbiddenDeny:
+    def test_literature_writing_ideas_denied(self, monkeypatch, workspace, fixtures_dir, payload_builder):
+        p = payload_builder("Write",
+                            {"file_path": str(workspace / ".copilot" / "ideas.md")},
+                            str(fixtures_dir / "transcript_copilot_literature.jsonl"))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "deny"
+        log = (workspace / ".copilot" / "__violations.log").read_text(encoding="utf-8")
+        assert "HARD" in log and "DENY" in log
+
+    def test_literature_editing_state_denied(self, monkeypatch, workspace, fixtures_dir, payload_builder):
+        p = payload_builder("Edit",
+                            {"file_path": str(workspace / ".copilot" / "state.md")},
+                            str(fixtures_dir / "transcript_copilot_literature.jsonl"))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+class TestOverride:
+    def test_skip_owned_check_allows(self, monkeypatch, workspace, fixtures_dir, payload_builder):
+        (workspace / ".copilot" / ".guard_override").write_text(
+            "copilot-literature: skip-owned-check until 2099-01-01T00:00:00Z\n",
+            encoding="utf-8")
+        p = payload_builder("Write",
+                            {"file_path": str(workspace / ".copilot" / "ideas.md")},
+                            str(fixtures_dir / "transcript_copilot_literature.jsonl"))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+    def test_env_var_off_allows(self, monkeypatch, workspace, fixtures_dir, payload_builder):
+        monkeypatch.setenv("COPILOT_HOOK_GUARD", "off")
+        p = payload_builder("Write",
+                            {"file_path": str(workspace / ".copilot" / "ideas.md")},
+                            str(fixtures_dir / "transcript_copilot_literature.jsonl"))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+
+class TestSafeMain:
+    def test_empty_stdin_falls_open(self, monkeypatch, workspace):
+        monkeypatch.setattr("sys.stdin", StringIO(""))
+        monkeypatch.chdir(workspace)
+        out = StringIO()
+        monkeypatch.setattr("sys.stdout", out)
+        guard.real_main()
+        d = json.loads(out.getvalue().strip().splitlines()[-1])
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+
+class TestHandoffSpecial:
+    def _writer_transcript(self, tmp_path: Path) -> str:
+        t = tmp_path / "writer.jsonl"
+        t.write_text('{"role":"assistant","metadata":{"subagent_type":"copilot-writer"}}\n')
+        return str(t)
+
+    def _ideation_transcript(self, tmp_path: Path) -> str:
+        t = tmp_path / "ideation.jsonl"
+        t.write_text('{"role":"assistant","metadata":{"subagent_type":"copilot-ideation"}}\n')
+        return str(t)
+
+    def test_writer_edit_handoff_allowed(self, monkeypatch, workspace, tmp_path, payload_builder):
+        p = payload_builder("Edit",
+                            {"file_path": str(workspace / ".copilot" / "handoff.md")},
+                            self._writer_transcript(tmp_path))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "allow"
+
+    def test_writer_write_handoff_denied(self, monkeypatch, workspace, tmp_path, payload_builder):
+        p = payload_builder("Write",
+                            {"file_path": str(workspace / ".copilot" / "handoff.md")},
+                            self._writer_transcript(tmp_path))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "deny"
+        assert "append" in d["hookSpecificOutput"]["permissionDecisionReason"].lower()
+
+    def test_ideation_writing_handoff_denied(self, monkeypatch, workspace, tmp_path, payload_builder):
+        p = payload_builder("Edit",
+                            {"file_path": str(workspace / ".copilot" / "handoff.md")},
+                            self._ideation_transcript(tmp_path))
+        d = _run(monkeypatch, p, workspace)
+        assert d["hookSpecificOutput"]["permissionDecision"] == "deny"

package/dist/hooks/tests/test_session_start_snapshot.py

@@ -0,0 +1,116 @@
+"""Tests for snapshot-writing side-effect of session_start_memory_injector."""
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+import _copilot_hook_lib as lib
+
+
+def _run_injector(workspace: Path) -> tuple[str, int]:
+    script = Path(__file__).resolve().parent.parent / "scripts" / "session_start_memory_injector.py"
+    proc = subprocess.run(
+        [sys.executable, str(script)],
+        cwd=str(workspace),
+        capture_output=True,
+        text=True,
+        timeout=10,
+    )
+    return proc.stdout, proc.returncode
+
+
+class TestSnapshotWriting:
+    def test_writes_for_existing_handoff(self, workspace, handoff_writer):
+        f = workspace / ".copilot" / "literature.md"
+        handoff_writer(f, last_updated="2026-05-24T10:00:00Z",
+                       written_by="copilot-literature")
+        stdout, rc = _run_injector(workspace)
+        assert rc == 0
+        snap = lib.read_snapshot(workspace)
+        assert snap.get("literature.md") == "2026-05-24T10:00:00Z"
+
+    def test_overwrites_each_run(self, workspace, handoff_writer):
+        f = workspace / ".copilot" / "literature.md"
+        handoff_writer(f, last_updated="2026-05-24T08:00:00Z")
+        _run_injector(workspace)
+        f.write_text("\n## __HANDOFF__\n- last_updated: 2026-05-24T12:00:00Z\n",
+                     encoding="utf-8")
+        _run_injector(workspace)
+        snap = lib.read_snapshot(workspace)
+        assert snap.get("literature.md") == "2026-05-24T12:00:00Z"
+
+    def test_snapshot_file_created(self, workspace, handoff_writer):
+        f = workspace / ".copilot" / "literature.md"
+        handoff_writer(f, last_updated="2026-05-24T10:00:00Z")
+        _run_injector(workspace)
+        assert (workspace / ".copilot" / ".session_snapshot.json").is_file()
+
+
+import datetime
+
+
+class TestViolationsSummary:
+    def _write_log(self, workspace, records):
+        log = workspace / ".copilot" / "__violations.log"
+        log.write_text("\n".join(json.dumps(r) for r in records) + "\n",
+                       encoding="utf-8")
+
+    def test_empty_log_no_summary(self, workspace, handoff_writer):
+        handoff_writer(workspace / ".copilot" / "literature.md",
+                       last_updated="2026-05-24T10:00:00Z")
+        stdout, rc = _run_injector(workspace)
+        assert "Last 24h" not in stdout
+
+    def test_recent_blocks_summarized(self, workspace, handoff_writer):
+        handoff_writer(workspace / ".copilot" / "literature.md",
+                       last_updated="2026-05-24T10:00:00Z")
+        now = datetime.datetime.now(datetime.timezone.utc)
+        recent = (now - datetime.timedelta(hours=1)).isoformat().replace("+00:00", "Z")
+        self._write_log(workspace, [
+            {"ts": recent, "sev": "HARD", "kind": "BLOCK", "agent": "copilot-literature", "detail": "x"},
+            {"ts": recent, "sev": "HARD", "kind": "BLOCK", "agent": "copilot-literature", "detail": "y"},
+            {"ts": recent, "sev": "HARD", "kind": "RELEASE", "agent": "copilot-literature", "detail": "z"},
+            {"ts": recent, "sev": "SOFT", "kind": "WARN", "agent": "copilot-experiment", "detail": "w"},
+        ])
+        stdout, rc = _run_injector(workspace)
+        assert "Last 24h" in stdout
+        assert "2 HARD" in stdout
+        assert "1 SOFT" in stdout
+
+    def test_old_entries_ignored(self, workspace, handoff_writer):
+        handoff_writer(workspace / ".copilot" / "literature.md",
+                       last_updated="2026-05-24T10:00:00Z")
+        now = datetime.datetime.now(datetime.timezone.utc)
+        old = (now - datetime.timedelta(hours=48)).isoformat().replace("+00:00", "Z")
+        self._write_log(workspace, [
+            {"ts": old, "sev": "HARD", "kind": "BLOCK", "agent": "x", "detail": "old"},
+        ])
+        stdout, rc = _run_injector(workspace)
+        assert "1 HARD" not in stdout
+
+
+def test_injects_conductor_protocol(tmp_path, monkeypatch, capsys):
+    import session_start_memory_injector as inj
+    (tmp_path / ".copilot").mkdir()
+    # Seed a real __HANDOFF__ block so `blocks` is non-empty and main() reaches
+    # the injection point (it does NOT inject on the early "no blocks" return).
+    (tmp_path / ".copilot" / "state.md").write_text(
+        "## __HANDOFF__\n- last_updated: 2026-05-24T10:00:00Z\n"
+        "- written_by: conductor\n- key_facts:\n  - S1 in progress\n"
+        "- next_owner: (none)\n",
+        encoding="utf-8",
+    )
+    monkeypatch.chdir(tmp_path)
+    # Point the protocol lookup at a temp file. NOTE: this test runs the injector
+    # IN-PROCESS (not via subprocess like the other tests in this file) precisely
+    # so conductor_protocol_path can be monkeypatched — do not "fix" it to subprocess.
+    proto = tmp_path / "CONDUCTOR-PROTOCOL.md"
+    proto.write_text("# Conductor Protocol\nYou are the conductor.\n", encoding="utf-8")
+    monkeypatch.setattr(inj, "conductor_protocol_path", lambda: proto)
+    inj.main()
+    out = capsys.readouterr().out
+    assert "You are the conductor" in out

package/dist/hooks/tests/test_state_machine_consistency.py

@@ -0,0 +1,75 @@
+"""Meta-test: STATE_MACHINE dict must match each agent.md state table."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import pytest
+
+import _copilot_hook_lib as lib
+
+AGENTS_DIR = Path(__file__).resolve().parent.parent.parent / "agents"
+
+AGENT_FILES = {
+    "conductor":           AGENTS_DIR.parent / "CONDUCTOR-PROTOCOL.md",
+    "copilot-literature":  AGENTS_DIR / "copilot-literature.agent.md",
+    "copilot-ideation":    AGENTS_DIR / "copilot-ideation.agent.md",
+    "copilot-experiment":  AGENTS_DIR / "copilot-experiment.agent.md",
+    "copilot-writer":      AGENTS_DIR / "copilot-writer.agent.md",
+    "copilot-polisher":    AGENTS_DIR / "copilot-polisher.agent.md",
+    "copilot-reviewer":    AGENTS_DIR / "copilot-reviewer.agent.md",
+    "copilot-rebuttal":    AGENTS_DIR / "copilot-rebuttal.agent.md",
+}
+
+
+def _parse_state_table(text: str) -> dict[str, list[str]]:
+    """Best-effort: find a markdown table whose header contains 状态 and
+    可能的下一状态, parse first-column (state) and last-column (next states).
+
+    Last column format: `[A, B, C]` or `[A]` or `[]`. Whitespace tolerated.
+    """
+    lines = text.splitlines()
+    result: dict[str, list[str]] = {}
+    in_table = False
+    for line in lines:
+        s = line.strip()
+        if s.startswith("|") and "状态" in s and "可能的下一状态" in s:
+            in_table = True
+            continue
+        if not in_table:
+            continue
+        if not s.startswith("|"):
+            if result:
+                break  # table ended
+            continue
+        if set(s.replace("|", "").strip()) <= set("-: "):
+            continue  # separator row like |---|---|
+        cols = [c.strip() for c in s.strip("|").split("|")]
+        if len(cols) < 5:
+            continue
+        state = cols[0]
+        m = re.search(r"\[([^\]]*)\]", cols[-1])
+        if not m:
+            continue
+        inner = m.group(1).strip()
+        next_states = [x.strip() for x in inner.split(",") if x.strip()] if inner else []
+        result[state] = next_states
+    return result
+
+
+@pytest.mark.parametrize("agent,path", list(AGENT_FILES.items()))
+def test_state_machine_matches_agent_md(agent: str, path: Path):
+    assert path.is_file(), f"agent.md missing: {path}"
+    parsed = _parse_state_table(path.read_text(encoding="utf-8"))
+    coded = lib.STATE_MACHINE.get(agent, {})
+    if not parsed:
+        pytest.xfail(f"could not parse state table in {path.name}")
+    for state, next_states in parsed.items():
+        assert state in coded, (
+            f"{agent}: state '{state}' in agent.md but missing from STATE_MACHINE")
+        assert set(next_states) == set(coded[state]), (
+            f"{agent}: state '{state}' drift — agent.md={next_states} vs "
+            f"coded={coded[state]}")
+    for state in coded.keys():
+        assert state in parsed, (
+            f"{agent}: state '{state}' in STATE_MACHINE but missing from agent.md")

package/dist/skills/arxivsub-skill/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: arxivsub-skill
+description: "Use whenever the user wants to search for academic papers, find recent research, look up conference publications, or explore literature on any AI / ML / CV topic. Routes through the `arxivsub-search` MCP server (arXiv + CVPR / ICCV / ICLR / ICML / NeurIPS / AAAI / MICCAI). Triggers on: \"find papers on X\", \"what are the latest papers about Y\", \"search arXiv for Z\", \"any recent work on W\", '论文检索', '最新研究'."
+version: 0.2.0
+---
+
+# arxivsub-skill
+
+Search academic papers via the arXIVSub API through MCP.
+
+## Language Rule
+
+**Always respond in the same language the user is using.**
+
+## Step 0: Authentication
+
+The `arxivsub-search` MCP server reads the API key automatically from the environment or a `.env` file at the workspace root. Never ask the user for it unless the MCP call fails with a missing-key or auth error, and never pass it as a chat parameter.
+
+If the MCP tool reports `missing_api_key` or an auth failure involving `ARXIVSUB_SKILL_KEY`, tell the user (in their language) to set it up via **one** of:
+
+1. Export as a shell environment variable (add to `~/.zshrc` or `~/.bashrc` for persistence):
+   ```
+   export ARXIVSUB_SKILL_KEY=your_key_here
+   ```
+2. Add to a `.env` file in the working directory:
+   ```
+   ARXIVSUB_SKILL_KEY=your_key_here
+   ```
+
+The user's API key is found on the Skills page of the arXivSub website.
+
+## Step 1: Show search parameters and execute
+
+Before calling the API, briefly show the interpreted parameters in one line (in the user's language), then proceed without waiting:
+
+> Searching: query=`"..."`, locations=`[...]`, time=`...`, limit=`...`
+
+Pause only if the search intent is genuinely ambiguous (e.g. a term that could mean multiple very different topics).
+
+## Step 2: Call MCP search
+
+Call `arxivsub-search.search_papers` with the interpreted parameters. Omit `arxiv_days` / `conference_years` if not applicable.
+
+Expected MCP arguments:
+
+```json
+{
+  "query": "<search terms>",
+  "locations": ["arxiv", "CVPR", "NeurIPS"],
+  "limit": 10,
+  "arxiv_days": 7,
+  "conference_years": [2024, 2025],
+  "language": "en"
+}
+```
+
+The MCP tool returns full paper details and `quota_remaining` in structured content. Do not create temp JSON files.
+
+## Step 3: Filter and rank
+
+From the returned list, select the **top 5–10** using:
+1. **Relevance first** — how directly the paper addresses the query
+2. **Recency as tiebreaker** — among equally relevant papers, prefer the most recent
+
+## Step 4: Fetch full details and respond
+
+Compose the response from the returned details. **Never mention files, scripts, temp files, or internal mechanics.**
+
+### Output structure (translate headers to the user's language)
+
+**[Research Findings]** — Synthesize insights. Answer the user's question directly.
+
+**[Recommended Papers]** — For each paper, write a substantive description (not just `what_about`). Cover: what problem it solves, the key method or contribution, and notable results or significance. Typically 3–5 sentences.
+
+```
+**[Title]**
+📍 [conference / arXiv] · [year if available]
+👥 [first_author] ([first_aff]) · [last_author] ([last_aff])
+📄 [synthesized description based on full paper details]
+🔗 [pdf_url]
+```
+
+At the bottom, show quota in the user's language as a footnote:
+English: `Daily quota remaining: N searches` / Chinese: `当日剩余搜索额度：N 次`
+
+## Key rules
+
+- `locations` is **case-sensitive**: `arxiv`, `CVPR`, `ICCV`, `ICLR`, `ICML`, `NeurIPS`, `AAAI`, `MICCAI`
+- Show parameters as a one-liner before calling the MCP; only ask for confirmation if intent is ambiguous
+- If the MCP returns an error, classify and handle:
+  - **Retryable** (network timeout, transient server error): inform the user; offer to retry
+  - **Needs user intervention**:
+    - Quota exhausted → tell the user the daily quota is used up; do not retry
+    - Auth failure / missing key → go to Step 0
+    - Empty results → suggest broadening the query (fewer locations, wider date range, looser terms)
+    - JSON parse failure / malformed response → report as an unexpected error; ask the user to try again later
+- NEVER output raw JSON or expose internal mechanics
+- NEVER call local skill scripts; all network access MUST go through MCP

package/dist/skills/arxivsub-skill/skill.json

@@ -0,0 +1,5 @@
+{
+  "name": "arxivsub-skill",
+  "description": "Use whenever the user wants to search for academic papers, find recent research, look up conference publications, or explore literature on any AI / ML / CV topic. Routes through the `arxivsub-search` MCP server (arXiv + CVPR / ICCV / ICLR / ICML / NeurIPS / AAAI / MICCAI). Triggers on: \"find papers on X\", \"what are the latest papers about Y\", \"search arXiv for Z\", \"any recent work on W\", '论文检索', '最新研究'.",
+  "entry": "SKILL.md"
+}

package/dist/skills/de-ai-checker/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: de-ai-checker
+description: "Validation skill for de-AI quality checking. Use AFTER polishing to verify that AI patterns have been removed and text reads naturally. Triggers on: 'check de-AI quality', 'verify humanization', 'validate polish', 'de-AI checker', '检查去AI效果'. This is a validation-gate compatible wrapper around paper-deai."
+version: 1.0.0
+---
+
+# De-AI Checker — Post-polish validation
+
+Run **after** polishing is complete to verify that AI patterns have been successfully removed and the text reads naturally.
+
+## When this skill fires
+
+Fire automatically when:
+- The polisher agent reaches the VERIFYING state and needs validation-gate clearance
+- User explicitly requests de-AI quality verification
+- After any `paper-deai` rewriting pass to confirm quality
+
+Also fires on user request: "检查去AI效果" / "check de-AI quality" / "verify the polish worked"
+
+## Purpose
+
+This skill serves as a **validation-gate compatible checker** that:
+1. Verifies AI patterns have been removed
+2. Confirms text naturalness and academic register
+3. Provides pass/fail validation for capability gates
+4. Delegates actual rewriting to `paper-deai` if issues are found
+
+## Procedure
+
+### Step 1 — Read the polished text
+
+Load the text that was just polished. This should be LaTeX content from the target sections.
+
+### Step 2 — Run AI pattern detection
+
+Check for common AI fingerprints:
+
+| Pattern Category | What to check |
+|---|---|
+| **Over-used vocabulary** | Scan for the AI-over-used word list: leverage, delve, tapestry, endeavor, underscore, etc. (full list in `paper-deai` skill) |
+| **Mechanical connectives** | Look for: "First and foremost", "It is worth noting that", "Moreover", "Furthermore" at sentence starts |
+| **List format** | Check for `\item` usage where prose would be more natural |
+| **Excessive dashes** | Count em-dashes (`---` and `—`) — more than 1 per paragraph is suspicious |
+| **Tense errors** | Verify background/prior-art uses present perfect ("have achieved") not simple present |
+| **Emphasis abuse** | Check for bold/italics used for emphasis rather than structure |
+
+### Step 3 — Score and decide
+
+Calculate a naturalness score based on:
+- AI vocabulary count (each instance: -10 points)
+- Mechanical connectives (each instance: -5 points)
+- List format in prose sections (each `\item`: -8 points)
+- Excessive dashes (each beyond 1/paragraph: -3 points)
+- Tense errors (each instance: -7 points)
+
+**Pass threshold**: Score ≥ 85/100
+
+### Step 4 — Output validation report
+
+```markdown
+## De-AI validation report — <section>
+- Date: <YYYY-MM-DD>
+- Text reviewed: <file:line range>
+- Naturalness score: <score>/100
+- Status: [PASS] or [FAIL]
+- Issues found:
+  - AI vocabulary: <count> instances → <list with line numbers>
+  - Mechanical connectives: <count> instances → <list>
+  - List format: <count> items → <list>
+  - Excessive dashes: <count> → <list>
+  - Tense errors: <count> → <list>
+- Recommendation: <"Validation passed" or "Re-run paper-deai on sections: <list>">
+```
+
+### Step 5 — Auto-fix if requested
+
+If the validation fails and the user/agent requests auto-fix:
+1. Call the `paper-deai` skill with the problematic sections
+2. Re-run this validation checker
+3. Report final status
+
+## Output format
+
+- **Part 1 [Validation Report]**: The structured report above
+- **Part 2 [Gate Status]**: One of:
+  - `[VALIDATION_GATE_PASS]` — text is natural, no AI patterns detected
+  - `[VALIDATION_GATE_FAIL]` — AI patterns remain, re-polish required
+
+## Integration with capability gates
+
+This skill satisfies the `validation-gate` requirement because:
+- Name matches `*-checker` pattern
+- Provides explicit pass/fail status
+- Can be called via `Skill(skill='de-ai-checker')`
+
+## Hard constraints
+
+- **Post-polish only** — if no polished text exists, exit and recommend running `paper-deai` first
+- **Read before checking** — every issue must cite file:line, not "in general"
+- **Honest scoring** — do not inflate scores to declare victory
+- **Delegate rewriting** — this skill validates; `paper-deai` rewrites
+- **One pass per invocation** — do not loop; if re-check is needed, user/agent re-invokes
+- **Explicit gate status** — always output `[VALIDATION_GATE_PASS]` or `[VALIDATION_GATE_FAIL]`
+
+## Relationship to paper-deai
+
+- `paper-deai`: **Executor** — rewrites text to remove AI patterns
+- `de-ai-checker`: **Validator** — checks quality and provides gate clearance
+
+Use `paper-deai` for rewriting, use `de-ai-checker` for validation.

package/dist/skills/de-ai-checker/skill.json

@@ -0,0 +1,5 @@
+{
+  "name": "de-ai-checker",
+  "description": "Validation skill for de-AI quality checking. Use AFTER polishing to verify that AI patterns have been removed and text reads naturally. Triggers on: 'check de-AI quality', 'verify humanization', 'validate polish', 'de-AI checker', '检查去AI效果'. This is a validation-gate compatible wrapper around paper-deai.",
+  "entry": "SKILL.md"
+}

package/dist/skills/deep-interview/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: deep-interview
+description: "Pre-plan Socratic clarification. Use BEFORE drafting any plan (ideation direction, experiment Goal anchor, rebuttal strategy, pipeline routing) to expose hidden assumptions, lock topology, and converge on scope. Walks the decision tree one branch at a time with a recommended answer per question and an explicit ambiguity score, stopping only when the score crosses the threshold. Triggers on: '帮我厘清需求', '我有个想法不太明确', '在写计划前先聊清楚', '深度访谈', 'clarify before planning', 'deep interview', 'requirements interview', 'scope before plan'."
+version: 0.2.0
+---
+
+# Deep Interview — Pre-plan clarification gate
+
+Run **before** any plan is drafted. Purpose: turn a vague user ask into a crystallised spec the downstream planner can execute literally. This skill does NOT write the plan itself — when the ambiguity score crosses the threshold, hand off to the appropriate agent / planning skill.
+
+## When this skill fires
+
+Fire automatically when the next action is one of:
+
+- Drafting the **Goal anchor** in `.copilot/experiments.md` (first experiment dispatch)
+- Picking a **research direction** in `.copilot/ideas.md` (ideation Step A)
+- Deciding the **rebuttal response-strategy** per reviewer comment
+- Choosing the **routing template** for the conductor (full pipeline / submission sprint / custom sequence)
+- Any other moment where a sub-agent is about to commit a plan to disk
+
+Skip if a `## Goal anchor` (or equivalent immutable plan block) already exists — do not re-interview about a settled commitment.
+
+## Operating principles
+
+1. **One question per round.** Each round ships exactly one question + your recommended answer + a one-sentence reason. Never dump 3–5 parallel questions.
+2. **Read before you ask.** If the answer is in `.copilot/{state, literature, ideas, experiments, handoff, decisions}.md`, workspace tex/code/logs, or recent reviewer rounds — read first, then ask only what remains.
+3. **Topology first.** Round 0 enumerates 1–6 independent components of the ask (e.g. for "submission sprint": writer pass / polish / review / rebuttal-prep — pick which are in scope). Lock the component list before drilling into any single one.
+4. **Rotate across components.** When >1 component is active, rotate targeting so no single component reaches clarity while siblings stay vague.
+5. **Score every round.** After each answer, score four dimensions on 0–1:
+   - **goal** — does the user know the *what*?
+   - **constraints** — compute / data / deadline / venue / word-limit bounds named?
+   - **criteria** — falsification + success criteria explicit?
+   - **context** — is the existing `.copilot/` / codebase state cross-referenced? (brownfield only)
+   - Ambiguity = `1 − (goal·0.35 + constraints·0.25 + criteria·0.25 + context·0.15)` for brownfield, drop the context term and renormalise for greenfield.
+6. **Stop condition.** Exit when ambiguity ≤ **0.2** (default; the conductor may override) **or** after 20 rounds (hard cap — force exit and flag the residual gap).
+7. **Challenge injections.** At rounds 4 / 6 / 8 (once each), inject one of:
+   - **contrarian** — "what would a top-venue reviewer call your weakest assumption here?"
+   - **simplifier** — "which of these branches can we drop without breaking the core claim?"
+   - **ontologist** — "what is the single noun phrase this contribution renames or invents? where else does that noun already mean something different?"
+
+## Round template
+
+```
+Round <N>  (ambiguity: <prev_score> → after this round: <new_score>)
+
+Question: <one question>
+My recommendation: <answer + one-sentence reason; cite file path / line / `.copilot/...` if the basis is in the repo>
+What I will do once you answer: <next round's branch, or "exit and hand off to <agent>">
+```
+
+When invoked from an agent, use `AskUserQuestion` to render the question — never freeform-ask in main response text.
+
+## Output: the crystallised spec
+
+When the stop condition fires, emit:
+
+```markdown
+## Deep-interview spec — <slug>
+- Date: <YYYY-MM-DD>
+- Topology (locked at Round 0): <component list>
+- Goal: <one sentence>
+- Constraints: <compute / data / deadline / venue / word-limit, each with a number>
+- Success criterion: <how we know it worked>
+- Falsification criterion: <how we know it failed>
+- Residual ambiguity: <final score> on dimensions <list any below 0.6>
+- Hand off to: <agent or skill that will draft the plan>
+```
+
+Write this block to the file the downstream planner will read:
+
+| Downstream planner | Spec lands in |
+|---|---|
+| `@copilot-experiment` Step 1 (Goal anchor) | `.copilot/experiments.md` (above the Goal anchor) |
+| `@copilot-ideation` Step B | `.copilot/ideas.md` `## User preferences` block |
+| `@copilot-rebuttal` Step 2 (per-comment strategy) | top of `rebuttal/round-N.md` |
+| conductor pipeline routing | `.copilot/decisions.md` |
+
+Do not write the plan itself in this step — only the spec.
+
+## Hand-off
+
+End with one line stating which agent / skill picks up next, e.g. "→ hand off to `@copilot-experiment` to draft the Goal anchor from this spec." After hand-off, the next agent **must** run `grill-with-docs` once its plan is drafted, to gap-check the plan against `.copilot/` documentation and glossary.
+
+## Hard constraints
+
+- **One question per round** — no parallel question dumps
+- **Read first, ask second** — never ask about facts already in `.copilot/` or the workspace
+- **No plan writing** — only the spec block; the downstream agent writes the plan
+- **Do not skip Round 0 topology** — single-component asks still benefit from explicit enumeration
+- **Honest ambiguity scores** — neither inflate to declare victory nor deflate to keep drilling
+- **Exit at hard cap** — at round 20, exit and flag the residual gap; do not loop forever

package/dist/skills/deep-interview/skill.json

@@ -0,0 +1,5 @@
+{
+  "name": "deep-interview",
+  "description": "Pre-plan Socratic clarification. Use BEFORE drafting any plan (ideation direction, experiment Goal anchor, rebuttal strategy, pipeline routing) to expose hidden assumptions, lock topology, and converge on scope. Walks the decision tree one branch at a time with a recommended answer per question and an explicit ambiguity score, stopping only when the score crosses the threshold. Triggers on: '帮我厘清需求', '我有个想法不太明确', '在写计划前先聊清楚', '深度访谈', 'clarify before planning', 'deep interview', 'requirements interview', 'scope before plan'.",
+  "entry": "SKILL.md"
+}