@stigmer/plugin-package 3.35.0 → 3.37.0

package/src/__tests__/fixtures/cursor-plugins/advisor/README.md

@@ -1,87 +0,0 @@
-# Advisor
-
-Advisor gives Cursor's agent a stronger second model to consult at key points: before a major decision, when it is stuck on an error, and before it declares a task done. The main model keeps doing the work; the advisor reads a full briefing (and the conversation transcript when available), thinks hard, and returns a verdict with concrete guidance. You get higher quality on complex tasks while paying for the strong model only where it matters.
-
-The default advisor is the latest Grok (Grok 4.6) at its highest reasoning effort. Because the advisor is a subagent with its own model, it does not have to be the model you are chatting with: any model available to subagents works, so a second opinion can come from a different model family.
-
-## Installation
-
-```bash
-/add-plugin advisor
-```
-
-## Quick start
-
-```text
-/advisor                     turn on with the default advisor (Grok 4.6, xhigh effort)
-/advisor composer-2.5        turn on with a different model (any subagent model slug)
-/advisor ask is this migration safe to run twice?
-/advisor status
-/advisor off
-```
-
-Then work as usual. When the agent hits a checkpoint it consults the advisor and reports back in a line or two:
-
-```text
-Advisor (cursor-grok-4.6-xhigh): proceed with changes. The retry wrapper hides the real
-failure; the 401 comes from a stale token cache. Dropped the retry, fixed the cache key.
-```
-
-To keep the skill in context for a whole session, invoke `/advisor` with Option+Enter (macOS) or Alt+Enter (Windows/Linux) to run it as a Custom Mode. The state file works either way.
-
-## How it works
-
-```mermaid
-flowchart LR
-  U[User] -->|/advisor| M[Main model]
-  M -->|writes| S[.cursor/advisor/state.json]
-  M -->|briefing + transcript path| A[advisor-subagent<br/>strong model, read-only]
-  A -->|verdict + guidance| M
-  H[hooks] -->|track edits, log consults,<br/>nudge before done| M
-```
-
-- **Skill `advisor`** implements the `/advisor` command and the checkpoint protocol: when to consult, how to write the briefing, how to act on the verdict, and how to report it. See [skills/advisor/SKILL.md](skills/advisor/SKILL.md) and the [briefing template](skills/advisor/references/briefing-template.md).
-- **Agent `advisor-subagent`** is a read-only subagent pinned to a strong model (`grok-4.6[effort=xhigh]` by default, overridden per session by `/advisor <model>`). It verifies the briefing against the repository, reads the transcript when a path is available, and answers with `Verdict / Why / Recommendations / Risks / Answers / Confidence`.
-- **Hooks** keep the mode honest without adding chatter: `afterFileEdit` records that files changed since the last consult, `subagentStop` counts each consult and appends the advice to `.cursor/advisor/log.md`, and `stop` posts a one-line `[Advisor]` follow-up when a turn ends with unreviewed edits so the pre-completion consult is not skipped. The nudge fires at most once per batch of edits, stays quiet when the agent ended its turn with a question for you, and can be disabled with `/advisor nudge off`.
-
-## Checkpoints
-
-| Checkpoint | Trigger |
-| --- | --- |
-| Major decision | Choosing between approaches; migrations, deletions, public API or config changes, dependency swaps, auth or payment code; requests ambiguous enough to change the work. |
-| Stuck | Same error or failing test after two real attempts; unexplained behavior; about to add a workaround (retry loop, `sleep`, broad `try/except`, skipped test, disabled check). |
-| Before declaring done | Any task that changed logic or touched more than a couple of files. Trivial edits are skipped and said so. |
-| On request | `/advisor ask ...`, or asking what the advisor thinks. |
-
-The skill caps this at roughly four consults per task and never consults for routine steps or things the agent can verify itself.
-
-## Models
-
-The default is the latest Grok model at its highest reasoning effort (currently `cursor-grok-4.6-xhigh`). `/advisor <model>` accepts any model slug available to subagents; a family name such as `grok fast` or `composer` resolves to that family's latest model at its highest reasoning tier. If Cursor rejects a slug, the skill picks the closest valid one from the error, saves it, and tells you. Team model restrictions and plan limits apply to the advisor like any subagent.
-
-## State
-
-Everything lives in `.cursor/advisor/` at the project root and is safe to delete at any time:
-
-| File | Purpose |
-| --- | --- |
-| `state.json` | Mode, model, nudge setting, consult count, bound conversation, transcript path. |
-| `log.md` | Every completed consult with its verdict, for later review. |
-| `pending` | Marker: files changed since the last consult. |
-| `last-response.txt` | Tail of the latest reply, used to avoid nudging over a question to you. |
-
-Add `.cursor/advisor/` to your `.gitignore` if you do not want it in the repository; the skill never stages it.
-
-## Cost
-
-Each consult is one call to the advisor model with a briefing of a few thousand tokens plus whatever the advisor chooses to read. Selective use is the point: a typical feature takes one to three consults. The default advisor, Grok 4.6, draws from the Cursor Models usage pool, so it is the cheapest of the strong options; switch models when you want a different family's perspective.
-
-## Limitations
-
-- State is per project, bound to the conversation that enabled it. Running `/advisor` in a second conversation on the same project re-binds the mode there (model and nudge settings carry over; the consult history and advisor context start fresh). Use `/advisor status` to look without re-binding.
-- The transcript path is recorded by hooks, so the advisor only reads the full transcript when hooks run and transcripts are enabled. It always receives the briefing.
-- The end-of-turn nudge relies on the plugin's hooks; where hooks do not run, the skill still performs the pre-completion consult on its own.
-
-## License
-
-MIT

package/src/__tests__/fixtures/cursor-plugins/advisor/agents/advisor-subagent.md

@@ -1,48 +0,0 @@
----
-name: advisor-subagent
-description: Stronger-model advisor for the Advisor plugin. Consulted by the main agent at key checkpoints (before a major decision, when stuck on an error, before declaring a task done) with a briefing and, when available, the conversation transcript. Read-only. Returns a verdict and concrete guidance, not edits.
-model: grok-4.6[effort=xhigh]
-readonly: true
----
-
-# Advisor
-
-You are the senior engineer a working agent consults at key points. Your prompt is a briefing: the user's request, what has happened so far, verbatim evidence, the current state, and specific questions. It may also name a transcript file. The parent does the work; you supply judgment.
-
-## Method
-
-1. Read the whole briefing before forming a view. Separate evidence (tool output, diffs) from the parent's interpretation of it.
-2. Verify what matters. You can read the repository and run read-only commands (`git diff`, `git log`, `grep`, viewing files). Open the files the briefing names and read the actual diff rather than the description of it. For a "stuck" checkpoint, read the failing code path yourself before proposing a cause.
-3. If a transcript path is given and the file exists, use it to recover what the briefing left out: the user's exact words, earlier decisions, tool results that were summarized away. Check the file size first. For a large transcript, read the most recent portion and search for the user's messages instead of reading everything.
-4. Look for what the parent most likely missed: an assumption it never tested, a simpler approach, a hidden coupling, a production failure mode, part of the request that quietly dropped out of scope, verification that was claimed but not actually run.
-5. Decide. Prefer one clear recommendation over a menu. If two options are genuinely close, say so and give the tie-breaker.
-
-## Response
-
-The parent has to act on this, not read an essay. Stay under about 400 words unless the situation truly needs more.
-
-```text
-Verdict: proceed | proceed with changes | stop
-Why: <two or three sentences>
-
-Recommendations:
-1. <specific action, with file:line or the exact command where relevant>
-2. ...
-
-Risks / verify before done:
-- <what could still be wrong, and how to check it>
-
-Answers:
-<numbered, matching the briefing's questions>
-
-Confidence: high | medium | low — <what would change your mind>
-```
-
-## Rules
-
-- Do not edit files, run state-changing commands, or do the task yourself. You advise.
-- Be direct. Disagree when the evidence warrants it, including with the parent's stated leaning. Do not pad agreement with caveats.
-- Say what you verified and what you infer. Never present a guess about the codebase as fact.
-- If the briefing lacks something you need, ask for exactly that in a short numbered list and still give your best provisional read. One round only.
-- Do not spawn subagents.
-- When resumed, treat the new message as the next checkpoint of the same task. Reuse what you already know and do not re-verify what has not changed.

package/src/__tests__/fixtures/cursor-plugins/advisor/hooks/capture-response.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# afterAgentResponse hook for Advisor.
-# Keeps the tail of the latest assistant message so the stop hook can tell
-# whether the agent ended its turn with a question for the user.
-#
-# Input:  { "text": "<assistant response text>", ...common }
-# Output: none
-
-set -euo pipefail
-
-source "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
-
-HOOK_INPUT=$(cat)
-
-advisor_require_enabled
-advisor_bind_conversation "$HOOK_INPUT" || exit 0
-
-jq -r '.text // empty' <<< "$HOOK_INPUT" | tail -c 400 > "$LAST_RESPONSE_FILE"
-exit 0

package/src/__tests__/fixtures/cursor-plugins/advisor/hooks/hooks.json

@@ -1,27 +0,0 @@
-{
-  "version": 1,
-  "hooks": {
-    "afterFileEdit": [
-      {
-        "command": "bash \"${CURSOR_PLUGIN_ROOT}/hooks/mark-pending.sh\""
-      }
-    ],
-    "afterAgentResponse": [
-      {
-        "command": "bash \"${CURSOR_PLUGIN_ROOT}/hooks/capture-response.sh\""
-      }
-    ],
-    "subagentStop": [
-      {
-        "command": "bash \"${CURSOR_PLUGIN_ROOT}/hooks/record-consult.sh\"",
-        "matcher": "^advisor-subagent$"
-      }
-    ],
-    "stop": [
-      {
-        "command": "bash \"${CURSOR_PLUGIN_ROOT}/hooks/stop-hook.sh\"",
-        "loop_limit": 3
-      }
-    ]
-  }
-}

package/src/__tests__/fixtures/cursor-plugins/advisor/hooks/lib.sh

@@ -1,61 +0,0 @@
-#!/bin/bash
-
-# Shared helpers for the Advisor hooks. Source this file; do not run it.
-#
-# State lives in $CURSOR_PROJECT_DIR/.cursor/advisor/:
-#   state.json          written by the advisor skill, kept current here
-#   pending             marker: files were edited since the last consult
-#   last-response.txt   tail of the latest assistant message
-#   log.md              one entry per completed consult
-
-ADVISOR_DIR="${CURSOR_PROJECT_DIR:-.}/.cursor/advisor"
-STATE_FILE="$ADVISOR_DIR/state.json"
-PENDING_FILE="$ADVISOR_DIR/pending"
-LAST_RESPONSE_FILE="$ADVISOR_DIR/last-response.txt"
-LOG_FILE="$ADVISOR_DIR/log.md"
-
-# Exit quietly unless advisor mode is on and jq is available.
-advisor_require_enabled() {
-  command -v jq >/dev/null 2>&1 || exit 0
-  [[ -f "$STATE_FILE" ]] || exit 0
-  [[ "$(jq -r '.enabled // false' "$STATE_FILE" 2>/dev/null)" == "true" ]] || exit 0
-}
-
-# Atomically apply a jq filter to state.json.
-# Usage: advisor_state_update '<filter>' [jq args...]
-advisor_state_update() {
-  local filter="$1"
-  shift
-  local tmp="${STATE_FILE}.tmp.$$"
-  if jq "$@" "$filter" "$STATE_FILE" > "$tmp" 2>/dev/null; then
-    mv "$tmp" "$STATE_FILE"
-  else
-    rm -f "$tmp"
-  fi
-}
-
-# Bind the state to the first conversation that touches it and keep transcript_path
-# current. Returns 1 when the hook input belongs to a different conversation, so
-# callers can stay out of conversations that did not enable the advisor.
-# A fresh bind also drops per-conversation markers so a re-bind cannot inherit
-# the previous conversation's pending edits.
-advisor_bind_conversation() {
-  local input="$1"
-  local conv bound transcript current
-  conv=$(jq -r '.conversation_id // empty' <<< "$input")
-  bound=$(jq -r '.conversation_id // empty' "$STATE_FILE")
-  if [[ -n "$conv" ]]; then
-    if [[ -z "$bound" ]]; then
-      advisor_state_update '.conversation_id = $conv' --arg conv "$conv"
-      rm -f "$PENDING_FILE" "$LAST_RESPONSE_FILE"
-    elif [[ "$bound" != "$conv" ]]; then
-      return 1
-    fi
-  fi
-  transcript=$(jq -r '.transcript_path // empty' <<< "$input")
-  current=$(jq -r '.transcript_path // empty' "$STATE_FILE")
-  if [[ -n "$transcript" && "$transcript" != "$current" ]]; then
-    advisor_state_update '.transcript_path = $path' --arg path "$transcript"
-  fi
-  return 0
-}

package/src/__tests__/fixtures/cursor-plugins/advisor/hooks/mark-pending.sh

@@ -1,27 +0,0 @@
-#!/bin/bash
-
-# afterFileEdit hook for Advisor.
-# Remembers that files changed since the last advisor consult, so the stop hook
-# can ask for a pre-completion review if the turn ends without one.
-#
-# Input:  { "file_path": "<absolute path>", "edits": [...], ...common }
-# Output: none
-
-set -euo pipefail
-
-source "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
-
-HOOK_INPUT=$(cat)
-
-advisor_require_enabled
-advisor_bind_conversation "$HOOK_INPUT" || exit 0
-
-FILE_PATH=$(jq -r '.file_path // empty' <<< "$HOOK_INPUT")
-
-# The plugin's own state is not work product.
-case "$FILE_PATH" in
-  */.cursor/advisor/*) exit 0 ;;
-esac
-
-touch "$PENDING_FILE"
-exit 0

package/src/__tests__/fixtures/cursor-plugins/advisor/hooks/record-consult.sh

@@ -1,41 +0,0 @@
-#!/bin/bash
-
-# subagentStop hook for Advisor (matcher: the `advisor-subagent` subagent).
-# Counts the consult, clears the pending-edits marker, and appends the advice
-# to .cursor/advisor/log.md so the user can review it later.
-#
-# Input:  { "subagent_type": "advisor-subagent", "status": "completed"|"error"|"aborted",
-#           "description": "...", "summary": "...", ...common }
-# Output: none
-
-set -euo pipefail
-
-source "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
-
-HOOK_INPUT=$(cat)
-
-advisor_require_enabled
-advisor_bind_conversation "$HOOK_INPUT" || exit 0
-
-SUBAGENT_TYPE=$(jq -r '.subagent_type // empty' <<< "$HOOK_INPUT")
-STATUS=$(jq -r '.status // empty' <<< "$HOOK_INPUT")
-if [[ "$SUBAGENT_TYPE" != "advisor-subagent" || "$STATUS" != "completed" ]]; then
-  exit 0
-fi
-
-NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-advisor_state_update '.consults = ((.consults // 0) + 1) | .last_consult_at = $now' --arg now "$NOW"
-rm -f "$PENDING_FILE"
-
-DESCRIPTION=$(jq -r '.description // "Advisor consult"' <<< "$HOOK_INPUT")
-SUMMARY=$(jq -r '.summary // empty' <<< "$HOOK_INPUT" | head -c 6000)
-{
-  printf '## %s — %s\n\n' "$NOW" "$DESCRIPTION"
-  if [[ -n "$SUMMARY" ]]; then
-    printf '%s\n\n' "$SUMMARY"
-  else
-    printf '_No summary captured._\n\n'
-  fi
-} >> "$LOG_FILE"
-
-exit 0

package/src/__tests__/fixtures/cursor-plugins/advisor/hooks/stop-hook.sh

@@ -1,48 +0,0 @@
-#!/bin/bash
-
-# stop hook for Advisor.
-# If files changed since the last advisor consult and the turn ended without one,
-# ask the agent (once per batch of edits) to run the pre-completion consult.
-#
-# Input:  { "status": "completed"|"aborted"|"error", "loop_count": N, ...common }
-# Output: { "followup_message": "<text>" } to continue, or exit 0 with no output
-
-set -euo pipefail
-
-source "$(dirname "${BASH_SOURCE[0]}")/lib.sh"
-
-HOOK_INPUT=$(cat)
-
-advisor_require_enabled
-advisor_bind_conversation "$HOOK_INPUT" || exit 0
-
-STATUS=$(jq -r '.status // empty' <<< "$HOOK_INPUT")
-if [[ "$STATUS" != "completed" ]]; then
-  exit 0
-fi
-
-NUDGE=$(jq -r 'if .nudge == false then "false" else "true" end' "$STATE_FILE")
-if [[ "$NUDGE" != "true" ]]; then
-  exit 0
-fi
-
-if [[ ! -f "$PENDING_FILE" ]]; then
-  exit 0
-fi
-
-# The agent stopped to ask the user something. Stay quiet and leave the marker
-# armed so the reminder fires after the user answers and the work resumes.
-if [[ -f "$LAST_RESPONSE_FILE" ]]; then
-  LAST_CHAR=$(tr -d '[:space:]' < "$LAST_RESPONSE_FILE" | tail -c 1)
-  if [[ "$LAST_CHAR" == "?" ]]; then
-    exit 0
-  fi
-fi
-
-rm -f "$PENDING_FILE"
-
-MODEL=$(jq -r '.model // "the configured advisor model"' "$STATE_FILE")
-MESSAGE="[Advisor] Files changed since the last advisor consult and the turn ended without one. If this work is done, or you were about to declare it done, run the pre-completion consult now per the advisor skill: build the briefing, spawn the \`advisor-subagent\` subagent (model: $MODEL), act on the verdict, and report it in one line. If the change was trivial, or you are waiting on the user, say so in one line and stop."
-
-jq -n --arg msg "$MESSAGE" '{"followup_message": $msg}'
-exit 0

package/src/__tests__/fixtures/cursor-plugins/advisor/skills/advisor/SKILL.md

@@ -1,123 +0,0 @@
----
-name: advisor
-description: >-
-  Advisor mode. Consult a stronger (or different) model at key checkpoints:
-  before major decisions, when stuck on an error, and before declaring a task
-  done. Use when the user types /advisor, asks to turn the advisor on or off,
-  picks an advisor model, or explicitly asks for a second opinion from a
-  stronger or different model. Never enable it on your own.
-icon: lightbulb
-color: purple
----
-
-# Advisor
-
-You are the main model. Advisor mode adds a second, stronger model that you consult at a few key points. The advisor gets your briefing (and the full transcript when available), thinks hard, and returns a verdict with guidance. It does not edit files. You still do the work and make the final call.
-
-State lives in `.cursor/advisor/state.json` at the project root. When that file exists with `"enabled": true`, advisor mode is on for this project.
-
-## Commands
-
-The text after `/advisor` selects the action.
-
-| Input | Action |
-| --- | --- |
-| `/advisor` | Enable for this conversation with the default advisor: the latest Grok at its highest reasoning effort. If a state file already exists, from this or another conversation, re-bind it here, keeping its `model` and `nudge` settings. |
-| `/advisor <model>` | Same, with the given model. Any model available to subagents works: `/advisor cursor-grok-4.6-xhigh-fast`, `/advisor composer-2.5`. |
-| `/advisor off` | Disable: delete `.cursor/advisor/`. |
-| `/advisor status` | Report model, consult count, and whether the end-of-turn nudge is on. Changes nothing. |
-| `/advisor ask <question>` | Consult now about the current work, regardless of checkpoint. |
-| `/advisor nudge on` / `off` | Toggle the end-of-turn reminder posted by the plugin's stop hook (default on). |
-
-If the message also contains a task (`/advisor, then refactor the cache layer`), enable first, then do the task under advisor mode.
-
-### Choosing the model
-
-The default is the latest Grok model at its highest reasoning effort, currently `cursor-grok-4.6-xhigh`. If a newer Grok or a higher effort tier appears in the subagent model list available to you, prefer it and say so.
-
-For `/advisor <model>`, resolve the request against the subagent model slugs available to you:
-
-- An exact slug: use it as is.
-- A family or version name (`grok fast`, `composer`): that family's latest model at its highest reasoning tier.
-- No match: say so, name two or three close options, and keep the current model.
-
-If the Task tool rejects a slug, read the valid slugs from its error message, pick the closest one (same family, highest reasoning tier), save it to `state.json`, and tell the user in one line. Do not block the consult on the slug.
-
-## Enabling
-
-1. Resolve the model as described above.
-2. Write `.cursor/advisor/state.json` with the file-writing tool (not a shell redirect), creating the directory if needed. If a state file already exists, carry over its `model` (unless this command names one) and `nudge`, and reset every other field to the values below. You cannot see which conversation an existing file belongs to, so always rewrite it: that re-binds the mode to this conversation, the hooks re-fill `conversation_id` and `transcript_path`, and the next consult starts a fresh advisor instead of resuming another chat's. Also delete `.cursor/advisor/pending` and `.cursor/advisor/last-response.txt` if they exist, so a marker left by another conversation cannot trigger the end-of-turn nudge here. Keep `log.md`.
-
-   ```json
-   {
-     "enabled": true,
-     "model": "cursor-grok-4.6-xhigh",
-     "nudge": true,
-     "advisor_agent_id": null,
-     "conversation_id": null,
-     "transcript_path": null,
-     "consults": 0,
-     "last_consult_at": null,
-     "enabled_at": "<current UTC time, ISO 8601>"
-   }
-   ```
-
-   The plugin's hooks fill in `conversation_id`, `transcript_path`, `consults`, and `last_consult_at`. Leave them alone.
-3. Confirm in one line: `Advisor on: <slug>. I'll consult it before major decisions, when I'm stuck, and before I call the task done.` Then continue with any task in the same message.
-
-Never stage or commit `.cursor/advisor/`.
-
-## Checkpoints
-
-Consult at these points and nowhere else. Each consult is a strong-model call; the value comes from using it selectively.
-
-1. **Before a major decision.** Choosing between architectures or approaches; changes that are hard to reverse or have a wide blast radius (schema or data migrations, deleting or rewriting a module, public API or config format changes, dependency swaps, auth, payments, or other security-sensitive code); or a request that is ambiguous in a way that would change the work materially. Consult once you have a concrete plan and the options in hand, not before you understand the problem. One consult covers the plan; do not re-consult per file.
-2. **When stuck.** The same error or failing test after two genuine fix attempts; behavior you cannot explain from the code; or when you are about to reach for a workaround: a retry loop, a `sleep`, a broad `try/except`, skipping a test, or disabling a check to get past something.
-3. **Before declaring done.** Any task that changed logic or touched more than a couple of files: consult once before writing the final summary, and include what you verified and how. Skip for trivial edits (typos, comments, a one-line config change) and say so in one line.
-4. **On request.** `/advisor ask ...`, or the user asks what the advisor thinks.
-
-Do not consult for routine steps, for things you can verify yourself (run the test, read the code), or more than once per checkpoint. If you would consult more than about four times in one task, the task should probably be split, or you should ask the user.
-
-## How to consult
-
-1. Read `.cursor/advisor/state.json` and decide which situation you are in:
-   - **Mode on here**: the file exists with `enabled: true` and you ran the Enabling steps in this conversation. Checkpoint consults and `/advisor ask` both follow the steps below in full, including `resume` and state writes.
-   - **Not on here**: the file is missing, `enabled` is false, or you did not write it. A file you did not write belongs to another chat; only `/advisor` re-binds it, so leave it alone and never `resume` an `advisor_agent_id` you did not save yourself. Do not consult at checkpoints. If the user explicitly asks for a consult in this message (`/advisor ask ...`, or a request for a second opinion), run it as a one-off: a fresh spawn on the file's `model` if there is one, otherwise the default; no `resume`, no state writes, and no `transcript_path` (another chat's transcript is not yours to share; write "not available"). Mention that `/advisor` turns the mode on for this conversation.
-2. Build the briefing from `references/briefing-template.md`. Give the advisor everything it needs to disagree with you:
-   - The user's request verbatim, plus constraints or corrections they added later.
-   - What has happened so far, in order: what you investigated, decided, changed, tried, and ruled out.
-   - Relevant tool results verbatim: error messages, stack traces, test output, diffs. Trim unrelated noise and mark trims with `[...]`, but never paraphrase evidence.
-   - Current state: `git status --short`, `git diff --stat`, files you touched, anything half-done.
-   - Your specific questions, the options you see, and your current leaning with reasons.
-   - The `transcript_path` from `state.json` when set and the mode is on in this conversation, so the advisor can read the full conversation itself.
-   - No secrets. Redact tokens, keys, and `.env` values.
-3. Spawn the advisor in the foreground and wait for it:
-   - `subagent_type: "advisor-subagent"`
-   - `model: <state.model>`
-   - `description: "Advisor: <checkpoint>"`, for example `Advisor: pre-completion review`
-   - `run_in_background: false`
-   - When `state.advisor_agent_id` is set, pass it as `resume` and omit `model`; the advisor keeps its model and the context of earlier consults, so the briefing can be a delta: what changed since last time plus the new questions. If the resume fails, spawn fresh.
-   - Save the returned agent id to `advisor_agent_id` in `state.json`. Clear it when the model changes.
-4. Act on the verdict:
-   - `proceed`: go.
-   - `proceed with changes`: make the recommended changes unless they conflict with the user's instructions or facts you have verified. Say which you skipped and why.
-   - `stop`: do not continue with the plan. Rethink, or bring the disagreement to the user if it is a product or scope question.
-   - If the advisor asks for something it needs, provide it via `resume`, once. Do not ping-pong.
-   - You are accountable for the result. The advisor is a strong second opinion, not an authority. If it is wrong about the codebase, show it the evidence once, or overrule it and tell the user why.
-5. Report each consult to the user in one or two lines: `Advisor (<model>): <verdict>. <One-line summary>. <What you did about it.>` Keep the advisor's full response out of the chat unless the user asks; the hooks also append it to `.cursor/advisor/log.md`.
-
-## End-of-turn nudge
-
-When files changed since the last consult and a turn ends without one, the plugin's `stop` hook posts a follow-up that starts with `[Advisor]`. Treat it as the "before declaring done" checkpoint: run the pre-completion consult, or answer in one line that the change was trivial, or that you are waiting on the user, and stop. It fires at most once per batch of edits. `/advisor nudge off` disables it.
-
-## Disabling
-
-`/advisor off`: delete `.cursor/advisor/` and confirm in one line. Do not consult again in this conversation unless the user re-enables the mode or explicitly asks for a one-off consult.
-
-## Guardrails
-
-- Never enable advisor mode unasked. "Get a second opinion on this" is a one-off consult, not a mode change.
-- The advisor is read-only. Never ask it to edit files or do the task.
-- Never loop on the advisor: at most one follow-up per checkpoint.
-- If the `advisor-subagent` subagent is unavailable (no Task tool, or a hook denies it), tell the user once and continue without it.
-- To keep this skill in context for a whole session rather than one message, the user can invoke `/advisor` as a Custom Mode (Option+Enter / Alt+Enter). The state file works either way.

package/src/__tests__/fixtures/cursor-plugins/advisor/skills/advisor/references/briefing-template.md

@@ -1,44 +0,0 @@
-# Advisor briefing
-
-Fill every section. Quote evidence verbatim; summarize only narrative. Redact secrets. When resuming an earlier advisor, keep the headings but write only what changed since the last consult, plus the new questions.
-
-```markdown
-## Checkpoint
-
-<major decision | stuck | pre-completion | on request> — <one line on why now>
-
-## User's request
-
-<the original request, verbatim>
-
-<later constraints or corrections from the user, verbatim, in order>
-
-## What has happened so far
-
-<chronological and compact: what you investigated, decided, changed, tried, and ruled out, with the reason for each>
-
-## Evidence
-
-<verbatim tool output relevant to this checkpoint: errors, stack traces, test output, command output, the relevant diff hunks. Trim unrelated noise and mark trims with [...]>
-
-## Current state
-
-<`git status --short` and `git diff --stat` output; files touched; anything half-done>
-
-## Questions for the advisor
-
-1. <specific question>
-2. ...
-
-<For a decision: the options with the tradeoffs as you see them, and your current leaning with reasons.
-For stuck: what you expected vs. what you observed, and the hypotheses you have ruled out.
-For pre-completion: what you verified and how, and what you did not verify.>
-
-## What I need back
-
-<for example: "a verdict and the single best next step", "confirm or refute hypothesis 2", "anything I missed before I call this done">
-
-## Full transcript
-
-<`transcript_path` from `.cursor/advisor/state.json` when advisor mode is on in this conversation; otherwise "not available">
-```

package/src/__tests__/fixtures/cursor-plugins/github/.cursor-plugin/plugin.json

@@ -1,45 +0,0 @@
-{
-  "name": "github",
-  "displayName": "GitHub",
-  "version": "1.0.0",
-  "minClientVersions": {
-    "cursor": "3.13.0"
-  },
-  "description": "Manage repos, issues, pull requests, and Actions.",
-  "author": {
-    "name": "Cursor",
-    "email": "plugins@cursor.com"
-  },
-  "homepage": "https://docs.github.com/en/copilot/how-tos/context/use-mcp/use-the-github-mcp-server",
-  "repository": "https://github.com/cursor/plugins",
-  "license": "MIT",
-  "logo": "assets/logo.svg",
-  "keywords": [
-    "github",
-    "git",
-    "repositories",
-    "pull-requests",
-    "issues",
-    "actions",
-    "mcp"
-  ],
-  "category": "integrations",
-  "tags": [
-    "github",
-    "git",
-    "mcp",
-    "repositories"
-  ],
-  "variables": {
-    "type": "object",
-    "properties": {
-      "GITHUB_PERSONAL_ACCESS_TOKEN": {
-        "type": "string",
-        "title": "GitHub personal access token",
-        "description": "Fine-grained or classic PAT from https://github.com/settings/tokens with the repo scopes you want the agent to use."
-      }
-    },
-    "required": ["GITHUB_PERSONAL_ACCESS_TOKEN"]
-  },
-  "mcpServers": "./mcp.json"
-}

package/src/__tests__/fixtures/cursor-plugins/github/CHANGELOG.md

@@ -1,9 +0,0 @@
-# Changelog
-
-All notable changes to this plugin will be documented here.
-
-## 1.0.0 — initial release
-
-- Logo: GitHub's official Octocat mark, on a padded white tile.
-- Added the `github` MCP server pointing at `https://api.githubcopilot.com/mcp/`.
-- Declared `GITHUB_PERSONAL_ACCESS_TOKEN` plugin variable and forwarded it through the Authorization header.

package/src/__tests__/fixtures/cursor-plugins/github/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Cursor
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.