# openspec-apply-change

Adopt this skill: https://proskills.md/skills/other/getsentry-flue-agents-claude-skills-openspec-apply-change

Page: https://proskills.md/skills/other/getsentry-flue-agents-claude-skills-openspec-apply-change
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: .claude/skills/openspec-apply-change/SKILL.md
size: 5225
upstream: https://github.com/getsentry/flue-agents/blob/main/.claude/skills/openspec-apply-change/SKILL.md

````text
---
name: openspec-apply-change
description: Implement tasks from an OpenSpec change. Use when the user wants to start implementing, continue implementation, or work through tasks.
license: MIT
compatibility: Requires openspec CLI.
metadata:
  author: openspec
  version: "1.0"
  generatedBy: "1.4.1"
---

Implement tasks from an OpenSpec change.

**Input**: Optionally specify a change name. If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.

**Steps**

1. **Select the change**

   If a name is provided, use it. Otherwise:
   - Infer from conversation context if the user mentioned a change
   - Auto-select if only one active change exists
   - If ambiguous, run `openspec list --json` to get available changes and use the **AskUserQuestion tool** to let the user select

   Always announce: "Using change: <name>" and how to override (e.g., `/opsx:apply <other>`).

2. **Check status to understand the schema**
   ```bash
   openspec status --change "<name>" --json
   ```
   Parse the JSON to understand:
   - `schemaName`: The workflow being used (e.g., "spec-driven")
   - `planningHome`, `changeRoot`, and `actionContext`: planning scope and edit constraints
   - Which artifact contains the tasks (typically "tasks" for spec-driven, check status for others)

3. **Get apply instructions**

   ```bash
   openspec instructions apply --change "<name>" --json
   ```

   This returns:
   - `contextFiles`: artifact ID -> array of concrete file paths (varies by schema - could be proposal/specs/design/tasks or spec/tests/implementation/docs)
   - Progress (total, complete, remaining)
   - Task list with status
   - Dynamic instruction based on current state

   **Handle states:**
   - If `state: "blocked"` (missing artifacts): show message, suggest using openspec-continue-change
   - If `state: "all_done"`: congratulate, suggest archive
   - Otherwise: proceed to implementation

   **Workspace guard:** If status JSON reports `actionContext.mode: "workspace-planning"` and `allowedEditRoots` is empty, explain that full workspace apply is not supported in this slice. Treat linked repos and folders as read-only context, ask the user to select an affected area through an explicit implementation workflow, and STOP before editing files.

4. **Read context files**

   Read every file path listed under `contextFiles` from the apply instructions output.
   The files depend on the schema being used:
   - **spec-driven**: proposal, specs, design, tasks
   - Other schemas: follow the contextFiles from CLI output

5. **Show current progress**

   Display:
   - Schema being used
   - Progress: "N/M tasks complete"
   - Remaining tasks overview
   - Dynamic instruction from CLI

6. **Implement tasks (loop until done or blocked)**

   For each pending task:
   - Show which task is being worked on
   - Make the code changes required
   - Keep changes minimal and focused
   - Mark task complete in the tasks file: `- [ ]` → `- [x]`
   - Continue to next task

   **Pause if:**
   - Task is unclear → ask for clarification
   - Implementation reveals a design issue → suggest updating artifacts
   - Error or blocker encountered → report and wait for guidance
   - User interrupts

7. **On completion or pause, show status**

   Display:
   - Tasks completed this session
   - Overall progress: "N/M tasks complete"
   - If all done: suggest archive
   - If paused: explain why and wait for guidance

**Output During Implementation**

```
## Implementing: <change-name> (schema: <schema-name>)

Working on task 3/7: <task description>
[...implementation happening...]
✓ Task complete

Working on task 4/7: <task description>
[...implementation happening...]
✓ Task complete
```

**Output On Completion**

```
## Implementation Complete

**Change:** <change-name>
**Schema:** <schema-name>
**Progress:** 7/7 tasks complete ✓

### Completed This Session
- [x] Task 1
- [x] Task 2
...

All tasks complete! Ready to archive this change.
```

**Output On Pause (Issue Encountered)**

```
## Implementation Paused

**Change:** <change-name>
**Schema:** <schema-name>
**Progress:** 4/7 tasks complete

### Issue Encountered
<description of the issue>

**Options:**
1. <option 1>
2. <option 2>
3. Other approach

What would you like to do?
```

**Guardrails**
- Keep going through tasks until done or blocked
- Always read context files before starting (from the apply instructions output)
- If task is ambiguous, pause and ask before implementing
- If implementation reveals issues, pause and suggest artifact updates
- Keep code changes minimal and scoped to each task
- Update task checkbox immediately after completing each task
- Pause on errors, blockers, or unclear requirements - don't guess
- Use contextFiles from CLI output, don't assume specific file names

**Fluid Workflow Integration**

This skill supports the "actions on a change" model:

- **Can be invoked anytime**: Before all artifacts are done (if tasks exist), after partial implementation, interleaved with other actions
- **Allows artifact updates**: If implementation reveals design issues, suggest updating artifacts - not phase-locked, work fluidly
````

## File: README.md
upstream: https://github.com/getsentry/flue-agents/blob/main/README.md

````text
# Sentry Flue Agents

Flue agents for Sentry automation, deployed on Cloudflare Workers.

## Layout

Flue modules live under `src/`.

```text
src/
├─ agents/       Addressable agents
├─ workflows/    Finite operations around agents
├─ skills/       Packaged Agent Skills imported by agents
├─ lib/          Shared implementation helpers
└─ cloudflare.ts Cloudflare-only Worker exports
fixtures/        Captured examples and regression inputs
```

## Issue Triage

`src/agents/issue-triage.ts` imports the `src/skills/issue-triage` skill and runs in a Cloudflare Sandbox container so it can use `gh`, `git`, and `pnpm` while inspecting GitHub issues and repositories.

The bounded issue-triage job is exposed as `src/workflows/issue-triage.ts`.

Issue-triage eval fixtures live in `fixtures/issue-triage/`. Vitest starts one
local Flue Node server for the suite, invokes a fresh workflow instance for each
fixture through `@flue/sdk`, and checks stable decision fields through
`vitest-evals`.

```bash
pnpm evals
```

`pnpm evals` defaults to `openrouter/anthropic/claude-sonnet-4.6`, matching the
provider and model used by the production Cloudflare Worker. Set
`OPENROUTER_API_KEY` in `.env.local` or your shell. The runner loads `.env`
first, then `.env.local`, with shell variables winning over both. Evals only
accept `openrouter/...` models. Model calls have a hard 120-second timeout. The
eval server receives no GitHub credentials and never calls GitHub; issue and
repository context comes entirely from the fixture. Each fixture runs with the
production issue-triage agent configuration and applies deterministic assertions
to the same normalized GitHub-visible outcome used by production. Fixtures may
also define a qualitative rubric scored by a separate `vitest-evals` judge on
usefulness, precision, structure, and restraint. Both the internal diagnosis and
the final outcome remain inspectable in `vitest-results.json`.

## Quick Start

Use Node.js 22.19 or newer, pnpm 11.1.1, Cloudflare auth, and a GitHub App installed on the repositories you want to triage.

```bash
pnpm install
cp .env.example .env.local
```

Create a GitHub App owned by the organization or bot account that should appear as the triage actor.

Configure the app:

- Metadata: read
- Contents: read
- Issues: read and write
- Webhook URL: `https://sentry-flue-agents.getsentry.workers.dev/channels/github/webhook`
- Webhook content type: `application/json`
- Webhook secret: generate one with `openssl rand -hex 32`
- Webhook events: subscribe to **Issues** only

Install the app with **Only select repositories** and choose the repositories this service should triage. Generate a private key, then copy these values into `.env.local`:

```env
# GitHub App General tab: use Client ID, not App ID.
GITHUB_APP_CLIENT_ID="Iv1..."

# GitHub App installation URL: /settings/installations/<this-number>
GITHUB_APP_INSTALLATION_ID="12345678"

# Downloaded GitHub App private key. Keep \n escapes if pasted on one line.
GITHUB_APP_PRIVATE_KEY="-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----"

# Same value as the GitHub App webhook secret.
GITHUB_WEBHOOK_SECRET="..."

# Internal token for manual/operator workflow calls.
FLUE_HTTP_TOKEN="..."
```

```bash
pnpm run test
pnpm run typecheck
pnpm run build
```

`pnpm run build` does not require GitHub App credentials.

Then run the Cloudflare dev server:

```bash
pnpm run dev
```

The dev server listens on `http://localhost:3583`. Local dev requires Cloudflare auth and a `.env.local` containing the GitHub App credentials. The `dev` script loads `.env.local` explicitly and disables Wrangler's automatic `.env` loading; `build` and `deploy` ignore dot-env files and use Wrangler production secrets.

Invoke the issue triage workflow manually:

```bash
set -a
source .env.local
set +a

curl "http://localhost:3583/workflows/issue-triage?wait=result" \
  -H "Authorization: Bearer $FLUE_HTTP_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"repository":"getsentry/sentry-mcp","issueNumber":1059,"dryRun":true}'
```

Use `dryRun: true` to run duplicate search, repository inspection, and structured diagnosis without comments or closure. The result includes proposed actions plus `bug_analysis` or `gap_analysis`, which makes behavior review safe before enabling mutations. Omit `dryRun` for the normal mutating workflow. Issue labels are always read-only; Pierre never applies or removes them.

The production GitHub App webhook uses `/channels/github/webhook` through Flue's GitHub channel package and starts workflow runs after signature verification. It currently admits `issues.opened` events only. The workflow endpoint is protected and should be used only for authorized manual/operator runs.

## Deploy

Merges to `main` deploy automatically through Cloudflare Workers Builds. See [DEPLOYMENT.md](DEPLOYMENT.md) for the Cloudflare dashboard settings and runtime secret setup.

See [OBSERVABILITY.md](OBSERVABILITY.md) for Sentry and Cloudflare logging setup.

See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and conventions for adding agents and workflows.
````
