qiongli 1.13.0 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qiongli",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "Qiongli Python-free academic workflow asset manager.",
   "author": {
     "name": "Jiaxin Peng",

package/payload/plugins/claude/qiongli/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "qiongli",
   "description": "Qiongli academic research workflow for literature, manuscripts, statistics, analysis code, reproducibility, rebuttal, submission, presentation, and stage-aware grill.",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "author": {
     "name": "Jiaxin Peng",
     "url": "https://github.com/jxpeng98"

package/payload/plugins/claude/qiongli/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "qiongli",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "Qiongli academic research workflow for literature, manuscripts, statistics, analysis code, reproducibility, rebuttal, submission, presentation, and stage-aware grill.",
   "author": {
     "name": "Jiaxin Peng",

package/payload/plugins/claude/qiongli/mcp/qiongli-literature-provider/index.mjs

@@ -14,6 +14,7 @@ import { appendSearchWarnings, searchDiagnostics } from "./diagnostics.mjs";
 import { buildEvidence } from "./evidence.mjs";
 import { dedupeResults, rankResults } from "./normalize.mjs";
 import { buildQueryPlan, buildSearchIntent, providerLimitFor } from "./query.mjs";
+import { buildHybridSearchPlan } from "./search-plan.mjs";
 import { searchArxiv } from "./providers/arxiv.mjs";
 import { searchCrossref } from "./providers/crossref.mjs";
 import { searchOpenAlex } from "./providers/openalex.mjs";
@@ -54,6 +55,89 @@ export const TOOL_DECLARATIONS = [
       properties: {}
     }
   },
+  {
+    name: "qiongli_search_plan",
+    description: "Plan provider MCP and platform-native literature search routing without executing platform-native search.",
+    inputSchema: {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        query: {
+          type: "string"
+        },
+        platform: {
+          type: "string",
+          description: "Host platform used to choose the default native search tool, for example codex, claude, or antigravity."
+        },
+        native_search_available: {
+          type: "boolean"
+        },
+        nativeSearchAvailable: {
+          type: "boolean"
+        },
+        native_search_tools: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        nativeSearchTools: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        query_variants: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        queryVariants: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        include_working_papers: {
+          type: "boolean"
+        },
+        includeWorkingPapers: {
+          type: "boolean"
+        },
+        fromYear: {
+          type: ["integer", "string"]
+        },
+        toYear: {
+          type: ["integer", "string"]
+        },
+        search_mode: {
+          type: "string"
+        },
+        searchMode: {
+          type: "string"
+        },
+        venue_filter: {
+          type: "string"
+        },
+        venueFilter: {
+          type: "string"
+        },
+        document_types: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        documentTypes: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        }
+      }
+    }
+  },
   {
     name: "qiongli_config_status",
     description: "Report shared Qiongli provider configuration status without exposing secrets.",
@@ -748,6 +832,11 @@ export function handleStatus(context = {}) {
   };
 }
 
+export function handleSearchPlan(input = {}, context = {}) {
+  const status = handleStatus(context);
+  return buildHybridSearchPlan(input, status.capability_mode, status.providers);
+}
+
 export function handleConfigStatus(context = {}) {
   const env = context.env ?? process.env;
   const config = resolveConfig(context);
@@ -933,6 +1022,10 @@ export async function handleToolCall(name, input = {}, context = {}) {
     return toolResult(handleStatus(context));
   }
 
+  if (name === "qiongli_search_plan") {
+    return toolResult(handleSearchPlan(input, context));
+  }
+
   if (name === "qiongli_config_status") {
     return toolResult(handleConfigStatus(context));
   }
@@ -976,7 +1069,7 @@ export async function startStdioServer() {
   await startJsonRpcStdioServer({
     serverInfo: {
       name: "qiongli-literature-provider",
-      version: "0.1.4"
+      version: "0.1.5"
     },
     listTools,
     handleToolCall

package/payload/plugins/claude/qiongli/mcp/qiongli-literature-provider/search-plan.mjs

@@ -0,0 +1,359 @@
+const PROVIDER_PROVENANCE_LABELS = Object.freeze([
+  "mcp:semantic_scholar",
+  "mcp:openalex",
+  "mcp:crossref",
+  "mcp:pubmed",
+  "mcp:arxiv"
+]);
+const PROVIDER_NAMES = Object.freeze(PROVIDER_PROVENANCE_LABELS.map((label) => label.replace(/^mcp:/, "")));
+const AGENT_INSTRUCTIONS = Object.freeze([
+  "MCP servers must not call Codex or Claude native search directly.",
+  "The active agent executes native_search_queries only when the platform exposes native search.",
+  "Do not treat native-search results as provider-reproducible records.",
+  "Write provider, native, and user-corpus records with distinct provenance labels."
+]);
+
+const DEFAULT_NATIVE_TOOLS = Object.freeze({
+  codex: "codex_web_search",
+  claude: "claude_web_search",
+  claude_code: "claude_web_search",
+  claudecode: "claude_web_search",
+  antigravity: "antigravity_search",
+  platform: "platform_native_search"
+});
+
+const LIMITATIONS = Object.freeze({
+  emptyQuery: "Search query is empty.",
+  noNative: "Platform-native search was not declared available.",
+  noProvider: "Provider MCP search is unavailable; native results require explicit provenance labels.",
+  noSearch: "No provider MCP search or platform-native search is available."
+});
+
+function cleanString(value, fallback = "") {
+  if (value === undefined || value === null) {
+    return fallback;
+  }
+
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    return "";
+  }
+
+  return String(value).trim();
+}
+
+function readAlias(input, names) {
+  for (const name of names) {
+    if (input[name] !== undefined) {
+      return input[name];
+    }
+  }
+
+  return undefined;
+}
+
+function normalizeStringList(value) {
+  const values = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  const normalized = [];
+  const seen = new Set();
+
+  for (const item of values) {
+    const cleaned = cleanString(item);
+    if (!cleaned) {
+      continue;
+    }
+
+    const key = cleaned.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    normalized.push(cleaned);
+  }
+
+  return normalized;
+}
+
+function readBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  if (typeof value === "string") {
+    return ["1", "true", "yes", "y", "available"].includes(value.trim().toLowerCase());
+  }
+
+  return Boolean(value);
+}
+
+function normalizeProviderCapabilityMode(value) {
+  return cleanString(value) === "provider_connected" ? "provider_connected" : "strategy_only";
+}
+
+function normalizePlatform(value) {
+  const normalized = cleanString(value, "unknown").replace(/[\s-]+/g, "_");
+  return normalized || "unknown";
+}
+
+function defaultNativeTool(platform) {
+  return DEFAULT_NATIVE_TOOLS[platform.toLowerCase()] ?? DEFAULT_NATIVE_TOOLS.platform;
+}
+
+function normalizeTool(value) {
+  return cleanString(value).replace(/\s+/g, "_");
+}
+
+function nativeSearchTools(input, platform, nativeAvailable) {
+  if (!nativeAvailable) {
+    return [];
+  }
+
+  const rawTools = readAlias(input, ["native_search_tools", "nativeSearchTools"]);
+  const configuredTools = normalizeStringList(rawTools).map(normalizeTool).filter(Boolean);
+  if (configuredTools.length > 0) {
+    return configuredTools;
+  }
+
+  return [defaultNativeTool(platform)];
+}
+
+function nativeSearchAvailable(input) {
+  const raw = readAlias(input, ["native_search_available", "nativeSearchAvailable"]);
+  return readBoolean(raw ?? false);
+}
+
+function hasOwn(input, name) {
+  return Object.prototype.hasOwnProperty.call(input, name);
+}
+
+function firstPresent(input, names) {
+  for (const name of names) {
+    if (hasOwn(input, name) && input[name] !== null && input[name] !== undefined) {
+      return input[name];
+    }
+  }
+
+  return undefined;
+}
+
+function searchFilters(input) {
+  const filters = {};
+  for (const [outputKey, names] of [
+    ["include_working_papers", ["include_working_papers", "includeWorkingPapers"]],
+    ["fromYear", ["fromYear"]],
+    ["toYear", ["toYear"]],
+    ["search_mode", ["search_mode", "searchMode"]],
+    ["venue_filter", ["venue_filter", "venueFilter"]]
+  ]) {
+    const value = firstPresent(input, names);
+    if (value !== undefined) {
+      filters[outputKey] = value;
+    }
+  }
+
+  const documentTypes = normalizeStringList(firstPresent(input, ["document_types", "documentTypes"]));
+  if (documentTypes.length > 0) {
+    filters.document_types = documentTypes;
+  }
+
+  return filters;
+}
+
+function queryEntries(input, query) {
+  if (!query) {
+    return [];
+  }
+
+  const queries = [query, ...normalizeStringList(readAlias(input, ["query_variants", "queryVariants"]))];
+  const entries = [];
+  const seen = new Set();
+  for (const candidate of queries) {
+    const key = candidate.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    entries.push({
+      query_id: `Q${entries.length + 1}`,
+      query: candidate,
+      source: entries.length === 0 ? "primary" : "variant"
+    });
+  }
+  return entries;
+}
+
+function providerNames(providerStatus) {
+  if (providerStatus === null || providerStatus === undefined) {
+    return [...PROVIDER_NAMES];
+  }
+
+  return PROVIDER_NAMES.filter((provider) => {
+    const value = providerStatus[provider];
+    if (value === "configured" || value === true) {
+      return true;
+    }
+    return Boolean(value && typeof value === "object" && value.configured);
+  });
+}
+
+function buildProviderQueries(entries, filters, names, providerConnected) {
+  if (!providerConnected || entries.length === 0) {
+    return [];
+  }
+
+  return names.flatMap((provider) =>
+    entries.map((entry) => ({
+      provider,
+      query_id: entry.query_id,
+      query: entry.query,
+      source: entry.source,
+      filters: { ...filters },
+      provenance_label: `mcp:${provider}`
+    }))
+  );
+}
+
+function buildNativeQueries(entries, platform, nativeTools, filters, nativeEnabled) {
+  if (!nativeEnabled || entries.length === 0) {
+    return [];
+  }
+
+  return nativeTools.flatMap((tool) =>
+    entries.map((entry) => ({
+      tool,
+      platform,
+      query_id: entry.query_id,
+      query: entry.query,
+      source: entry.source,
+      filters: { ...filters },
+      provenance_label: `native:${tool}`
+    }))
+  );
+}
+
+function executionSequence(providerQueries, nativeQueries) {
+  const sequence = [
+    {
+      actor: "agent",
+      action: "call qiongli_literature_status",
+      tool: "qiongli_literature_status"
+    },
+    {
+      actor: "agent",
+      action: "call qiongli_search_plan",
+      tool: "qiongli_search_plan"
+    }
+  ];
+
+  if (providerQueries.length > 0) {
+    sequence.push({
+      actor: "agent",
+      action: "call qiongli_literature_search",
+      tool: "qiongli_literature_search",
+      queries: "provider_queries"
+    });
+  }
+
+  if (nativeQueries.length > 0) {
+    sequence.push({
+      actor: "agent",
+      action: "execute platform-native search",
+      queries: "native_search_queries"
+    });
+  }
+
+  sequence.push({
+    actor: "agent",
+    action: "merge/dedupe/search_log",
+    inputs: ["provider_queries", "native_search_queries", "user_corpus"]
+  });
+  return sequence;
+}
+
+function mergePolicy() {
+  return {
+    dedupe_keys: ["doi", "title", "year", "provider_record_id", "native_url"],
+    provider_records: "Prefer provider MCP metadata for reproducible bibliographic fields.",
+    native_records: "Keep native-search records only with native provenance labels and source URLs.",
+    user_corpus_records: "Keep user-corpus records separate from provider and native search records.",
+    search_log: "Record provider and native query execution separately before merge and dedupe."
+  };
+}
+
+function executionMode({ query, providerConnected, nativeAvailable }) {
+  if (!query) {
+    return "strategy_only";
+  }
+  if (providerConnected && nativeAvailable) {
+    return "hybrid_search";
+  }
+  if (providerConnected) {
+    return "provider_connected";
+  }
+  if (nativeAvailable) {
+    return "native_only";
+  }
+
+  return "strategy_only";
+}
+
+function planLimitations({ query, providerConnected, nativeAvailable, mode }) {
+  if (!query) {
+    return [LIMITATIONS.emptyQuery];
+  }
+  if (providerConnected && !nativeAvailable) {
+    return [LIMITATIONS.noNative];
+  }
+  if (!providerConnected && nativeAvailable) {
+    return [LIMITATIONS.noProvider];
+  }
+  if (mode === "strategy_only") {
+    return [LIMITATIONS.noSearch];
+  }
+
+  return [];
+}
+
+export function buildHybridSearchPlan(input = {}, providerCapabilityMode = "strategy_only", providerStatus = undefined) {
+  const query = cleanString(input.query);
+  const platform = normalizePlatform(input.platform);
+  const nativeAvailable = nativeSearchAvailable(input);
+  const tools = nativeSearchTools(input, platform, nativeAvailable);
+  const names = providerNames(providerStatus);
+  let normalizedProviderMode = normalizeProviderCapabilityMode(providerCapabilityMode);
+  if (providerStatus !== undefined && names.length === 0) {
+    normalizedProviderMode = "strategy_only";
+  }
+  const providerConnected = normalizedProviderMode === "provider_connected" && names.length > 0;
+  const mode = executionMode({ query, providerConnected, nativeAvailable });
+  const filters = searchFilters(input);
+  const entries = queryEntries(input, query);
+  const providerQueries = buildProviderQueries(entries, filters, names, ["hybrid_search", "provider_connected"].includes(mode));
+  const nativeQueries = buildNativeQueries(entries, platform, tools, filters, ["hybrid_search", "native_only"].includes(mode));
+
+  return {
+    artifact_type: "qiongli_hybrid_search_plan",
+    query,
+    platform,
+    search_execution_mode: mode,
+    provider_capability_mode: normalizedProviderMode,
+    native_search_available: nativeAvailable,
+    native_search_tools: tools,
+    provider_queries: providerQueries,
+    native_search_queries: nativeQueries,
+    provenance_labels: {
+      provider: providerConnected ? names.map((provider) => `mcp:${provider}`) : [],
+      native: tools.map((tool) => `native:${tool}`),
+      user_corpus: ["user_corpus"]
+    },
+    execution_sequence: executionSequence(providerQueries, nativeQueries),
+    agent_instructions: [...AGENT_INSTRUCTIONS],
+    merge_policy: mergePolicy(),
+    limitations: planLimitations({
+      query,
+      providerConnected,
+      nativeAvailable,
+      mode
+    })
+  };
+}

package/payload/plugins/claude/qiongli/skills/qiongli-academic-present/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-academic-present
+description: Use when the user asks Qiongli for academic slides, scholarly presentation planning, Slidev, Beamer, PowerPoint, talk structure, or /academic-present routing.
+---
+
+# Qiongli Academic Present
+
+This Codex wrapper mirrors the cross-platform `/academic-present` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/academic-present.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/academic-present` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.

package/payload/plugins/claude/qiongli/skills/qiongli-academic-write/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-academic-write
+description: Use when the user asks Qiongli for manuscript writing, academic writing, related work, abstract, introduction, discussion, section drafting, or /academic-write routing.
+---
+
+# Qiongli Academic Write
+
+This Codex wrapper mirrors the cross-platform `/academic-write` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/academic-write.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/academic-write` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.

package/payload/plugins/claude/qiongli/skills/qiongli-build-framework/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-build-framework
+description: Use when the user asks Qiongli for conceptual framework, theory mapping, contribution framing, construct relationships, model building, or /build-framework routing.
+---
+
+# Qiongli Build Framework
+
+This Codex wrapper mirrors the cross-platform `/build-framework` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/build-framework.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/build-framework` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.

package/payload/plugins/claude/qiongli/skills/qiongli-code-build/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-code-build
+description: Use when the user asks Qiongli for academic analysis code, notebooks, reproducibility scripts, statistical pipelines, replication packages, or /code-build routing.
+---
+
+# Qiongli Code Build
+
+This Codex wrapper mirrors the cross-platform `/code-build` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/code-build.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/code-build` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.

package/payload/plugins/claude/qiongli/skills/qiongli-compliance-check/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-compliance-check
+description: Use when the user asks Qiongli for reporting compliance, PRISMA, CONSORT, STROBE, checklist review, citation risk, or /compliance-check routing.
+---
+
+# Qiongli Compliance Check
+
+This Codex wrapper mirrors the cross-platform `/compliance-check` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/compliance-check.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/compliance-check` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.

package/payload/plugins/claude/qiongli/skills/qiongli-ethics-check/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-ethics-check
+description: Use when the user asks Qiongli for ethics, IRB text, consent, deidentification, data governance, disclosure, or /ethics-check routing.
+---
+
+# Qiongli Ethics Check
+
+This Codex wrapper mirrors the cross-platform `/ethics-check` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/ethics-check.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/ethics-check` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.

package/payload/plugins/claude/qiongli/skills/qiongli-find-gap/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-find-gap
+description: Use when the user asks Qiongli to find research gaps, narrow a topic, assess novelty, choose a direction, map contributions, or /find-gap routing.
+---
+
+# Qiongli Find Gap
+
+This Codex wrapper mirrors the cross-platform `/find-gap` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/find-gap.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/find-gap` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.

package/payload/plugins/claude/qiongli/skills/qiongli-lit-review/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-lit-review
+description: Use when the user asks Qiongli for literature review, systematic review, PRISMA search, screening, extraction, synthesis, evidence mapping, related work, or /lit-review routing.
+---
+
+# Qiongli Lit Review
+
+This Codex wrapper mirrors the cross-platform `/lit-review` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/lit-review.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/lit-review` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.

package/payload/plugins/claude/qiongli/skills/qiongli-paper/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-paper
+description: Use when the user asks Qiongli for end-to-end paper planning, research workflow routing, academic project setup, stage selection, or /paper routing.
+---
+
+# Qiongli Paper
+
+This Codex wrapper mirrors the cross-platform `/paper` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/paper.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/paper` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.

package/payload/plugins/claude/qiongli/skills/qiongli-paper-read/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: qiongli-paper-read
+description: Use when the user asks Qiongli to read a paper, PDF, DOI, article, notes, claims, methods, contribution, evidence, or /paper-read routing.
+---
+
+# Qiongli Paper Read
+
+This Codex wrapper mirrors the cross-platform `/paper-read` workflow entrypoint.
+
+## Canonical Route
+
+- Use `$qiongli` as the main Qiongli skill for trigger rules, project guidance, and subject overlays.
+- Follow `../qiongli-workflow/workflows/paper-read.md` as the source of truth for task order, artifacts, and quality gates.
+- Keep behavior aligned with Claude Code `/paper-read` and Antigravity workflow routing.
+
+Do not duplicate or reinterpret workflow logic in this wrapper. If this wrapper and the canonical workflow disagree, the canonical workflow wins.