qiongli 1.2.2 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qiongli",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "description": "Qiongli academic research workflow installer and optional Python bridge runtime.",
   "author": {
     "name": "Jiaxin Peng",

package/payload/qiongli-workflow/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: qiongli
-description: Qiongli version: v1.2.2. Academic workflow for Codex, Claude Code, and Gemini. Use when a user needs to plan papers, run literature reviews, choose a paper type (empirical, qualitative, systematic review, methods, theory), select a workflow stage, and produce consistent artifacts under RESEARCH/[topic]/ with explicit task IDs, quality gates, and submission-ready outputs.
+description: Qiongli version: v1.3.0. Cross-platform academic research workflow for Codex, Claude / Claude Code, Gemini, and CLI. Use for academic research lifecycle work: paper planning, literature review, paper reading, gap finding, study design, manuscript writing, statistics, analysis code, reproducibility, proofread, rebuttal, submission, presentation, and stage-aware grill / critique. Route natural academic requests even when the user does not explicitly invoke $qiongli or a slash command.
 ---
 
 # Qiongli Academic Workflow
@@ -9,7 +9,7 @@ Run a model-agnostic paper workflow using shared Task IDs and artifact contracts
 
 This is a **self-contained skill package**. All assets needed for execution — workflows, skill specifications, output templates, standards, and agent roles — are bundled in subdirectories of this package. No external repo access is needed.
 
-Installed Qiongli workflow version: `v1.2.2`
+Installed Qiongli workflow version: `v1.3.0`
 
 ## Quick Start
 
@@ -20,9 +20,45 @@ Installed Qiongli workflow version: `v1.2.2`
 5. Apply quality gates before submission tasks (`H1`, `H2`).
 6. For orchestrator `task-run`, declare controller ownership when relevant with `--execution-mode`, `--controller`, `--primary`, `--reviewer`, `--verifier`, and `--solo-role-gates`.
 
+## Cross-Platform Trigger Contract
+
+Qiongli should be considered whenever a request belongs to the academic research lifecycle. This does not require explicit `$qiongli`, `/paper`, `/lit-review`, or slash-command invocation. Natural requests like "read this paper and summarize the contribution", "revise the methods section", "check whether this result supports the claim", "modify this analysis script", or "prepare a rebuttal" should route through the relevant Qiongli stage when the task has scholarly claim, evidence, method, venue, citation, reproducibility, or reviewer-risk consequences.
+
+Use Qiongli for:
+
+- framing a research topic, research question, hypothesis, contribution, theory, or venue fit
+- reading papers, PDFs, notes, citations, bibliographies, literature folders, or review matrices
+- searching, screening, mapping, extracting, or synthesizing literature
+- designing studies, variables, instruments, robustness checks, data plans, preregistration, or ethics materials
+- writing or revising proposals, manuscript sections, abstracts, tables, figures, claims maps, or discussion text
+- interpreting statistics, effect sizes, models, diagnostics, robustness checks, or analysis outputs
+- reading or editing academic analysis code, notebooks, Stata scripts, R scripts, Python scripts, Quarto files, or replication packages
+- checking PRISMA, reporting compliance, tone, citation support, originality, submission packages, rebuttals, peer review responses, or presentations
+
+Do not force Qiongli for:
+
+- generic software feature work unrelated to research analysis
+- generic prose editing without scholarly claim, evidence, venue, citation, or reviewer risk
+- file organization or format conversion without academic interpretation
+- project maintenance tasks for the Qiongli repository itself unless the user is changing research workflow behavior
+
+### Ambiguity Trigger
+
+When the user appears unsure, underspecified, or asks for judgment in an academic context, run a light boundary/grill step before producing a final artifact. Trigger phrases include: "I don't know how to start", "not sure", "help me decide", "which direction", "is this reasonable", "what should I do next", "帮我判断", "不知道怎么做", "不确定", "方向不清楚", "帮我想想", and "这样是否合理".
+
+The ambiguity response should inspect available artifacts first, then ask one blocking academic question with a recommended answer and rationale. Do not ask a broad questionnaire.
+
+### Platform Routing
+
+- Codex: skill or plugin discovery should route natural academic requests to Qiongli even without `$qiongli`; then load the relevant workflow or skill card.
+- Claude / Claude Code: skill package and plugin metadata should route natural academic requests to the matching task ID or workflow wrapper.
+- Gemini: extension and workflow prompts should preserve task IDs, artifact contracts, and stage-aware grill behavior.
+- CLI / npm / Python: command wrappers remain available, but the same routing contract applies to task packets and orchestrator runs.
+- Portable `qiongli-workflow`: synced skill packages must carry this trigger contract for non-plugin installs.
+
 ## Workflow Entry Points
 
-In Codex, invoke this skill with `/skills` or `$qiongli`, then ask for one of these workflows. Claude Code and Gemini surfaces may expose the same workflows as slash-style command wrappers:
+Explicit workflow commands are optional entry points. In Codex, users can invoke this skill with `/skills` or `$qiongli`, but natural academic requests should also route here. Claude Code and Gemini surfaces may expose the same workflows as slash-style command wrappers:
 
 ```
 /paper [topic] [venue]                # Master router — choose paper type + task ID

package/payload/qiongli-workflow/VERSION

@@ -1 +1 @@
-v1.2.2
+v1.3.0

package/payload/qiongli-workflow/references/platform-routing.md

@@ -1,6 +1,64 @@
 # Platform Routing
 
-Use this mapping to keep behavior consistent across tools.
+Use this mapping to keep behavior consistent across tools. Explicit workflow
+commands are helpful shortcuts, but Qiongli routing does not require explicit
+`$qiongli`, `/paper`, `/lit-review`, or slash-command invocation when the user is
+doing academic research lifecycle work.
+
+## Cross-Platform Trigger Contract
+
+Route to Qiongli when the user request involves academic research artifacts,
+judgment, or outputs:
+
+- topic framing, research question narrowing, hypothesis, contribution, theory, or
+  venue fit
+- paper/PDF/note reading, citation handling, bibliography work, literature search,
+  literature screening, extraction, synthesis, or gap mapping
+- study design, variable construction, instruments, data management, robustness
+  checks, preregistration, ethics, or IRB text
+- manuscript/proposal/abstract/table/figure/discussion/rebuttal/submission text
+- statistical interpretation, effect sizes, diagnostics, model output, robustness,
+  meta-analysis, or evidence synthesis
+- academic analysis code, notebooks, R/Stata/Python/Julia/MATLAB scripts, Quarto,
+  or replication packages when they affect data, models, tables, figures, results,
+  or reproducibility
+- proofread, de-AI rewriting, citation-risk checking, reviewer response,
+  peer-review simulation, fatal-flaw analysis, or academic presentations
+
+Do not route to Qiongli for generic software feature work, generic file cleanup,
+format conversion without scholarly interpretation, or prose edits with no claim,
+evidence, citation, venue, method, or reviewer-risk consequence.
+
+## Ambiguity Trigger
+
+When an academic request is vague or the user asks for judgment, run a light
+boundary/grill pass before producing a final artifact. Trigger phrases include:
+
+- English: "I don't know how to start", "not sure", "help me decide",
+  "which direction", "is this reasonable", "what should I do next"
+- Chinese: "帮我判断", "不知道怎么做", "不确定", "方向不清楚", "帮我想想",
+  "这样是否合理"
+
+The light pass must inspect available artifacts first, ask one blocking academic
+question, and include a recommended answer with rationale. Escalate to a deep
+stage-aware grill loop when the user explicitly asks to be grilled, stress-tested,
+challenged like Reviewer 2, or checked for fatal flaws.
+
+## Natural Request Routing Examples
+
+| User intent | Route |
+|---|---|
+| "Read this paper / PDF / DOI" | `B2` or `/paper-read` |
+| "Find gaps / I don't know where to start" | Stage A + ambiguity grill, then `A4` or `/find-gap` |
+| "Run a literature review" | `B1` or `/lit-review` |
+| "Improve related work" | `B4` or `/academic-write related-work` |
+| "Design the study / variables / robustness" | `C1`, `C3`, `C3_5`, or `/study-design` |
+| "Interpret these results" | `F3`, `F4`, `F5`, or `stats-engine` depending on artifact |
+| "Modify this analysis script / notebook" | Stage I, usually `I5 -> I6 -> I7 -> I8` for claim-supporting code |
+| "Proofread / make it less AI-like" | Stage J or `/proofread` |
+| "Prepare submission / cover letter" | `H1` or `/submission-prep` |
+| "Reply to reviewer comments" | `H2`, `H2_5`, or `/rebuttal` |
+| "Make slides" | Stage K or `/academic-present` |
 
 ## Claude Code
 
@@ -22,10 +80,14 @@ Use this mapping to keep behavior consistent across tools.
 - `I1–I8` -> `/code-build`
 - `J1–J4` -> `/proofread`
 - `K1–K4` -> `/academic-present`
+- Natural academic requests should route to the same task IDs even when the user
+  does not type the command wrapper.
+- If the request is ambiguous, use the Ambiguity Trigger before drafting.
 
 ## Codex
 
-- Use `$qiongli`
+- Use `$qiongli` when explicit invocation is available, but natural academic
+  requests should still route to Qiongli.
 - Provide: `paper_type`, `task_id`, `topic`, and optional `venue`
 - Follow artifact paths from workflow contract
 - For multi-agent execution, apply `standards/mcp-agent-capability-map.yaml`:
@@ -34,6 +96,8 @@ Use this mapping to keep behavior consistent across tools.
   - use `fallback_agent` when primary fails
 - For proofread tasks (`J1`–`J4`), recommend `--triad` mode for iterative de-AI
 - For presentation tasks (`K1`–`K4`), specify backend: `slidev`, `beamer`, or `pptx`
+- For academic code, prioritize estimand, data lineage, diagnostics, manuscript
+  tables/figures, and reproducibility over generic software scaffolding.
 
 ## Gemini
 
@@ -42,3 +106,20 @@ Use this mapping to keep behavior consistent across tools.
 - Keep task IDs and output file names unchanged
 - For proofread: `Execute Task J2 for paper_type {paper_type} in RESEARCH/{topic} using multi-agent collaboration to de-AI rewrite.`
 - For presentation: `Execute Task K1 for paper_type {paper_type} in RESEARCH/{topic} and prepare a conference talk using slidev backend.`
+- Gemini extension prompts should preserve the same Cross-Platform Trigger
+  Contract and Ambiguity Trigger when the user describes academic work naturally.
+
+## CLI / npm / Python
+
+- Slash-style commands and `qiongli task-run` remain the stable entry points.
+- Task packets from other platforms should preserve `paper_type`, `stage`,
+  `task_id`, `topic`, artifact paths, and open grill issues.
+- Orchestrator runs should carry boundary decisions and stage handoff risks into
+  downstream agents rather than resetting context.
+
+## Portable Skill Installs
+
+- `qiongli-workflow` portable packages must include this routing contract.
+- Desktop or web skill-only installs can route and write artifacts, but they
+  should not claim provider-connected literature search unless a provider MCPB or
+  platform-native search capability is available.

package/payload/qiongli-workflow/references/stage-I-code.md

@@ -29,6 +29,32 @@ Use a low-freedom sequence for reliability:
 4. **Independent review (`I8`)**: separate model reviews logic + stats validity + failure cases
 5. **Audit (`I4`)**: seeds, versions, determinism, data provenance, rerun instructions
 
+## Academic Analysis Code
+
+Stage I code is academic analysis code, not application architecture. Start from
+the estimand, hypothesis, analysis plan, or manuscript-facing table/figure that
+the code must support. Only add abstractions that make the research pipeline more
+auditable.
+
+Required analysis-code constraints:
+
+- Preserve dataset lineage: raw input, cleaning rules, exclusions, missingness,
+  joins, derived variables, and sample construction.
+- Treat model diagnostics and robustness checks as first-class outputs, not
+  optional plots added after the fact.
+- Write manuscript-facing tables, figures, and machine-readable result files to
+  predictable paths under `RESEARCH/[topic]/analysis/` or
+  `RESEARCH/[topic]/manuscript/`.
+- Record seeds, dependency notes, command logs, and rerun instructions.
+- Separate finding, interpretation, and implication in analysis reports.
+- Prefer scripts, notebooks, Quarto files, or small modules readable by
+  researchers over service layers, controllers, framework scaffolding, or
+  unnecessary classes.
+
+When exploratory analysis is requested, label outputs as exploratory and record
+assumptions. Do not let exploratory code silently become claim-supporting
+evidence without a Stage I specification, plan, execution record, and review.
+
 ## I8 — Academic Code Review
 
 **Definition of done**
@@ -45,6 +71,8 @@ Use a low-freedom sequence for reliability:
 - Contains runnable scripts/notebooks with clear entrypoints
 - Includes a minimal dataset stub or synthetic data generator for verification
 - Writes outputs to a predictable location (avoid hidden state)
+- Records dataset lineage, model diagnostics, robustness checks, and
+  manuscript-facing output paths
 
 ### `code/container_config/`
 - Optional but recommended when dependencies are fragile

package/payload/qiongli-workflow/references/stage-handoff-contract.md

@@ -10,15 +10,21 @@ Stage handoffs preserve what a downstream stage inherits and what remains uncert
 
 - `Completed Artifacts`
 - `Decision Summary`
+- `Resolved Grill Decisions`
 - `Unresolved Questions`
+- `Open Grill Issues`
 - `Evidence Dependencies`
 - `Assumptions Passed Forward`
 - `Risks For Next Stage`
+- `Revisit Triggers`
 - `Recommended Next Tasks`
 
 ## Rules
 
 - Link every completed artifact using a concrete `RESEARCH/[topic]/...` path or project-relative path.
 - Record unresolved questions explicitly; write `None` only when the stage has been checked.
+- Record `Resolved Grill Decisions` when a boundary interview, stage-aware grill, or self-critique loop closed a question that affects downstream scope, claim strength, methods, evidence thresholds, code, submission, or presentation.
+- Record `Open Grill Issues` when a light automatic grill or deep grill found a risk that cannot be resolved in the current stage.
 - Evidence dependencies should point to the evidence ledger, bibliography, analysis output, or gap note.
+- `Revisit Triggers` must state what new evidence, user decision, reviewer comment, diagnostic failure, or analysis result would reopen a resolved decision.
 - Do not treat a stage as ready for downstream work when inherited assumptions are hidden.

package/payload/qiongli-workflow/skills/I_code/code-builder.md

@@ -30,6 +30,20 @@ Academic code generation with multi-discipline, multi-language, and 2-tier compl
 
 Systematic conversion of academic methodologies into executable code (Python/R/Stata/MATLAB/Julia).
 
+## Academic Analysis Code
+
+Generated code must follow an academic analysis pipeline rather than a generic
+software-engineering scaffold. Start from the estimand, hypothesis, analysis
+plan, or manuscript-facing output that the code supports. Preserve dataset
+lineage from raw input through cleaning, exclusions, missingness, joins, derived
+variables, and sample construction. Make model diagnostics, robustness checks,
+and manuscript-facing tables/figures first-class outputs.
+
+Prefer scripts, notebooks, Quarto files, or small reusable functions that a
+researcher can read during peer review. Avoid service layers, controllers,
+framework scaffolding, unnecessary classes, or backend-style abstractions unless
+the method itself requires a reusable package.
+
 ## Domain Profiles
 
 Discipline-specific libraries, method templates, diagnostics, and pitfalls are defined in **`skills/domain-profiles/*.yaml`**. When `--domain` is specified, the corresponding profile is injected to guide library selection, method checklists, and common pitfalls.
@@ -126,6 +140,9 @@ Do NOT use high-level wrappers; implement from first principles."
 4. **Validation**: Test case proving correctness
 5. **Domain Checklist**: Pass/fail status for each domain-profile checklist item
 6. **Visualization**: Key diagnostic/result plots per domain profile `visualization_templates`
+7. **Dataset Lineage**: raw input, cleaning, exclusions, missingness, joins, derived variables, and sample construction
+8. **Manuscript Outputs**: manuscript-facing tables, figures, and result files with stable paths
+9. **Rerun Evidence**: seeds, dependency notes, exact commands, and rerun instructions
 
 ## Output Contract
 
@@ -141,6 +158,7 @@ Do NOT use high-level wrappers; implement from first principles."
 - [ ] 随机种子已固定且有文档说明
 - [ ] 核心函数有 docstring 和至少一个 assertion/test
 - [ ] 输出与 analysis plan 中预期的 table/figure 一一对应
+- [ ] dataset lineage、model diagnostics、robustness checks 和 manuscript-facing outputs 已明确写入产物
 
 ## Common Pitfalls
 

package/payload/qiongli-workflow/skills/I_code/code-planning.md

@@ -52,7 +52,8 @@ Transform code specifications into parallelizable, zero-decision execution plans
 2. **Order** tasks by dependencies and risk (do the riskiest first).
 3. **Define checkpoints** with concrete “pass/fail” criteria.
 4. **Plan artifacts**: where code, data, plots, and reports will be written.
-5. **Plan commands**: exact commands to run for each checkpoint.
+5. **Plan Academic Analysis Code evidence**: dataset lineage checks, model diagnostics, robustness checks, manuscript-facing tables/figures, and rerun evidence.
+6. **Plan commands**: exact commands to run for each checkpoint.
 
 ## Required plan format (`code/plan.md`)
 
@@ -83,7 +84,12 @@ primary_artifact: code/plan.md
       "checkpoint": "<observable pass/fail rule>",
       "rollback": "<recovery action>"
     }
-  ]
+  ],
+  "dataset_lineage_checks": ["..."],
+  "diagnostics": ["..."],
+  "robustness_checks": ["..."],
+  "manuscript_outputs": ["..."],
+  "rerun_evidence": ["..."]
 }
 ```
 
@@ -101,6 +107,14 @@ primary_artifact: code/plan.md
 | --- | --- | --- | --- | --- |
 | ... | ... | ... | ... | ... |
 
+## Academic Analysis Code Evidence Plan
+- Dataset lineage checks:
+- Model diagnostics:
+- Robustness checks:
+- Manuscript-facing outputs:
+- Rerun evidence:
+- Anti-pattern guard: avoid service layers, controllers, framework scaffolding, and unnecessary classes unless the specification explicitly justifies them.
+
 ## Exact Run Commands
 - ...
 

package/payload/qiongli-workflow/skills/I_code/code-specification.md

@@ -54,11 +54,17 @@ Generate strict constraint sets and requirement specifications before coding, fo
 2. **Specify I/O contracts**:
    - input files/columns/shapes
    - output artifacts (paths + formats)
-3. **List invariants**: properties that must always hold (e.g., probability sums to 1).
-4. **Enumerate edge cases**: missing data, empty groups, small-k meta-analysis, non-convergence.
-5. **Allowed dependencies**: language + libraries + version constraints.
-6. **Determinism rules**: seeds, randomness sources, hardware nondeterminism notes.
-7. **Validation plan**:
+3. **Lock Academic Analysis Code context**:
+   - estimand or target claim
+   - analysis_plan_source
+   - dataset lineage and sample construction
+   - manuscript_outputs for tables, figures, and result files
+   - model diagnostics and robustness_checks
+4. **List invariants**: properties that must always hold (e.g., probability sums to 1).
+5. **Enumerate edge cases**: missing data, empty groups, small-k meta-analysis, non-convergence.
+6. **Allowed dependencies**: language + libraries + version constraints.
+7. **Determinism rules**: seeds, randomness sources, hardware nondeterminism notes.
+8. **Validation plan**:
    - synthetic data checks
    - unit tests for core functions
    - regression tests for known examples
@@ -82,12 +88,26 @@ primary_artifact: code/code_specification.md
   "topic": "<topic>",
   "method_or_pipeline": "<name>",
   "primary_artifact": "code/code_specification.md",
+  "estimand": "<estimand-or-target-claim>",
+  "analysis_plan_source": "<path-or-summary>",
   "inputs": [
     {"path": "...", "schema": "..."}
   ],
   "outputs": [
     {"path": "...", "format": "..."}
   ],
+  "dataset_lineage": {
+    "raw_inputs": ["..."],
+    "cleaning_rules": ["..."],
+    "exclusions": ["..."],
+    "derived_variables": ["..."],
+    "sample_construction": "..."
+  },
+  "manuscript_outputs": [
+    {"path": "manuscript/tables/...", "supports_claim": "..."}
+  ],
+  "diagnostics": ["..."],
+  "robustness_checks": ["..."],
   "dependencies": {
     "python": ["package>=version"]
   },
@@ -114,6 +134,15 @@ primary_artifact: code/code_specification.md
 ## Outputs (Paths)
 - ...
 
+## Academic Analysis Code
+- Estimand / target claim:
+- Analysis plan source:
+- Dataset lineage:
+- Manuscript-facing outputs:
+- Model diagnostics:
+- Robustness checks:
+- Disallowed engineering scaffolding: service layers, controllers, framework scaffolds, and unnecessary classes unless explicitly justified.
+
 ## Functional Requirements
 1. ...
 

package/payload/qiongli-workflow/skills/Z_cross_cutting/boundary-interviewer.md

@@ -78,6 +78,76 @@ For Stage A idea-discovery, prefer questions that move from "interesting topic"
 - What contribution type is primary, and which adjacent contribution is not being claimed?
 - Who would cite this work if it succeeds, and why would they care?
 
+## Stage-Aware Grill Contract
+
+Use stage-aware grill as Qiongli's cross-platform academic judgment layer. The
+same contract applies in Codex, Claude / Claude Code, Gemini, CLI, and portable
+skill installs.
+
+Run a light automatic grill when:
+
+- a stage starts with vague or underdefined academic scope
+- a stage handoff contains open risks, stale decisions, or unresolved reviewer
+  concerns
+- a central claim, method, evidence threshold, analysis decision, submission
+  promise, or presentation claim changes
+- the user expresses uncertainty or asks for judgment, for example "not sure",
+  "help me decide", "不知道怎么做", "不确定", or "帮我判断"
+
+Run a deep grill when the user explicitly asks to be grilled, stress-tested,
+challenged, reviewed like Reviewer 2, or checked for fatal flaws. Deep grill
+continues the one-question loop until the key decision is resolved, blocked on
+external information, or deliberately carried forward as an open issue.
+
+Every grill question must:
+
+- inspect existing artifacts before asking
+- ask one blocking academic question at a time
+- include a recommended answer with academic rationale
+- state the likely evidence basis, claim-strength implication, reviewer or venue
+  consequence, and confidence
+- record the decision or unresolved issue for downstream stages
+
+### Stage-Specific Grill Lenses
+
+- Stage A: scope, contribution, claim strength, audience, and venue fit
+- Stage B: search bias, classic-paper deference, synthesis logic, rival
+  literatures, and inclusion/exclusion risk
+- Stage C: identification, measurement validity, rival hypotheses, data
+  feasibility, and power or sensitivity logic
+- Stage D: participant risk, privacy, consent clarity, governance, and dual-use
+  risk
+- Stage E: heterogeneity, publication bias, pooling defensibility, null cases,
+  and contradictory evidence
+- Stage F: claim-evidence alignment, causal language, interpretation depth,
+  alternative explanations, and limitation specificity
+- Stage G: reporting completeness, logical transitions, tone calibration, and
+  checklist compliance
+- Stage J: AI-trace risk, human scholarly voice, citation originality, and final
+  proofread integrity
+- Stage H: reviewer empathy, response tone, impossible requests, contradictions
+  introduced by revisions, and fatal flaw exposure
+- Stage I: estimand-to-code traceability, data lineage, diagnostic coverage,
+  reproducibility, computational assumptions, and analysis artifact outputs
+- Stage K: audience fit, claim compression, visual evidence integrity, slide
+  narrative, and unsupported simplification
+
+## Cross-Stage Grill Memory
+
+Grill decisions and unresolved issues must survive stage boundaries. Use:
+
+- `RESEARCH/[topic]/context/boundary_review.md` for locked scholarly boundaries
+- `RESEARCH/[topic]/context/decision_log.md` for resolved grill decisions and
+  rejected alternatives
+- `RESEARCH/[topic]/context/stage_handoff.md` for open grill issues, assumptions
+  passed forward, and revisit triggers
+- `RESEARCH/[topic]/review/self_critique_log.md` for issue lineage across review
+  rounds
+
+Downstream stages must inspect these artifacts before asking a new grill
+question. If a prior issue remains open, the downstream stage must resolve it,
+carry it forward, or explicitly mark why it is no longer relevant.
+
 ## When to Use
 
 - Before high-risk framing, study design, writing, submission, research code, or handoff work when scope, claim strength, evidence threshold, validity risk, generalizability, or reviewer expectations remain unclear.
@@ -87,8 +157,7 @@ For Stage A idea-discovery, prefer questions that move from "interesting topic"
 
 ## Related Task IDs
 
-- MVP trigger stages: `A`, `C`, `F`, `H`, `I`
-- Future trigger stages: `B`, `D`, `E`, `G`, `J`, `K`
+- Trigger stages: `A`, `B`, `C`, `D`, `E`, `F`, `G`, `J`, `H`, `I`, `K`
 
 ## Output (contract path)
 

package/payload/qiongli-workflow/skills/Z_cross_cutting/self-critique.md

@@ -64,6 +64,37 @@ Use `review/self_critique_log.md` as a compact register like:
 |---|---|---|---|---|---|---|---|
 | SC-01 | 0 | open | high | `manuscript/manuscript.md` / Discussion | Claim exceeds results evidence | Narrow causal language | Pending |
 
+## Stage-Aware Grill Contract
+
+When a task enters self-critique through a Qiongli grill request, use the same
+light automatic grill and deep grill distinction as `boundary-interviewer`.
+
+- Light automatic grill applies when the user is unsure, a stage starts with
+  vague scope, a handoff contains open risks, or a claim/method/evidence/code
+  decision changes.
+- Deep grill applies when the user explicitly asks to be grilled, stress-tested,
+  challenged like Reviewer 2, or checked for fatal flaws.
+- Every critique question must target the current stage lens, include a
+  recommended answer or required fix, and record whether the issue is open,
+  partial, resolved, or superseded.
+- A deep grill may reopen prior-stage issues only when it records the evidence or
+  user decision that triggered the revisit.
+
+## Cross-Stage Grill Memory
+
+Self-critique issues are part of the cross-stage grill memory. Before starting a
+new critique loop, inspect:
+
+- `context/boundary_review.md`
+- `context/decision_log.md`
+- `context/stage_handoff.md`
+- `review/self_critique_log.md`
+
+If a prior issue affects the current artifact, keep the same issue ID and update
+its status instead of creating a duplicate. Open issues that cannot be resolved in
+the current stage must be copied into `context/stage_handoff.md` under `Open
+Grill Issues` with a concrete `Revisit Trigger`.
+
 ## Stage-Specific Critique Questions
 
 ### Stage A: Framing & Positioning
@@ -134,6 +165,18 @@ Use `review/self_critique_log.md` as a compact register like:
 - *Q3:* "Are the computational environment dependencies explicitly pinned (e.g., requirements.txt, Dockerfile) to prevent 'works on my machine' syndrome?"
 - *Q4:* "Is there an unacknowledged O(N^2) or worse operation that will cause the code to hang if the dataset size scales 10x?"
 
+### Stage K: Academic Presentation
+- **Focus:** Audience fit, visual evidence integrity, and claim compression.
+- *Q1:* "Which claim is likely to be oversimplified on slides, and what evidence or caveat must stay visible?"
+- *Q2:* "Does every figure or table support the spoken argument, or is it decorative complexity?"
+- *Q3:* "What would a skeptical audience member challenge first, and is the answer already on a backup slide or speaker note?"
+
+### Stage J: Proofread & De-AI
+- **Focus:** Human scholarly voice, originality, and final integrity.
+- *Q1:* "Which sentences sound polished but empty, and what concrete claim or evidence should replace them?"
+- *Q2:* "Does the humanized text preserve citations, hedging, and claim strength from the source draft?"
+- *Q3:* "Could any rewrite change the meaning of methods, results, limitations, or author responsibility?"
+
 ## Usage
 
 This skill is injected into tasks by the `mcp-agent-capability-map.yaml` and should be called: