Skip to content
Claude Issue Implementation

Claude Issue Implementation #2911

Sign in to view logs

Claude Issue Implementation

Claude Issue Implementation #2911

Workflow file for this run

.github/workflows/claude-issue.yml at 2ff95fb
name: Claude Issue Implementation
# Serialized, durable runner for issue implementation.
#
# Requests are enqueued by claude-issue-enqueue.yml, which adds the
# `impl:queued` label (a durable queue entry). This runner drains that queue
# ONE issue at a time:
#
# * concurrency group `claude-impl` (cancel-in-progress: false) guarantees
# no two implementation runs — across this runner, claude-batch-fix, and
# claude-stale-check — ever execute at the same time, preventing
# conflicting branches/PRs against main.
# * The queue lives in labels, not in GitHub's pending-run slot, so nothing
# is ever silently dropped when many requests arrive at once (the failure
# that stranded issue #1039).
#
# Draining is driven by three triggers: the `labeled` event (fast path),
# a periodic `schedule` (backstop so the queue can never stall), and
# `workflow_dispatch` (self re-dispatch after each item + manual kick).
on:
issues:
types: [labeled]
schedule:
# Backstop: drain anything left in the queue even if a labeled/dispatch
# event was lost or evicted. Cheap no-op when the queue is empty.
- cron: "*/10 * * * *"
workflow_dispatch:
jobs:
claude:
# Only react to the queue label (or schedule / manual / self re-dispatch).
# Authorization is enforced at enqueue time; by the time `impl:queued`
# exists the request is already vetted.
if: |
github.event_name != 'issues' || github.event.label.name == 'impl:queued'
runs-on: ubuntu-latest
timeout-minutes: 75
# The single global implementation lock. Shared with claude-batch-fix and
# claude-stale-check so main-mutating automation is strictly serialized.
concurrency:
group: claude-impl
cancel-in-progress: false
permissions:
contents: write
pull-requests: write
issues: write
id-token: write
env:
MIX_ENV: test
# The "Pick next queued issue" step runs before checkout, so gh can't
# infer the repo from a local .git — GH_REPO targets it explicitly.
GH_REPO: ${{ github.repository }}
steps:
- name: Check PAT availability
run: |
if [ -z "${{ secrets.PAT_WORKFLOW_TRIGGER }}" ]; then
echo "::warning::PAT_WORKFLOW_TRIGGER secret not set - PRs won't trigger CI automatically"
fi
# Claim the oldest queued issue. Flips impl:queued -> impl:running so a
# concurrent enqueue can't double-process it. Exits cleanly (has_work=false)
# when the queue is empty, which makes schedule/spurious triggers no-ops.
- name: Pick next queued issue
id: pick
env:
GH_TOKEN: ${{ secrets.PAT_WORKFLOW_TRIGGER || github.token }}
run: |
set -euo pipefail
# FIFO-ish: oldest by issue number among queued, not-yet-running issues.
NEXT=$(gh issue list \
--repo "${{ github.repository }}" \
--label "impl:queued" \
--state open \
--json number,labels \
--jq '[ .[] | select([.labels[].name] | index("impl:running") | not) ]
| sort_by(.number) | .[0].number // empty')
if [ -z "${NEXT:-}" ]; then
echo "Queue empty — nothing to implement."
echo "has_work=false" >> "$GITHUB_OUTPUT"
exit 0
fi
echo "Claiming issue #$NEXT"
gh issue edit "$NEXT" --add-label "impl:running" --remove-label "impl:queued"
echo "has_work=true" >> "$GITHUB_OUTPUT"
echo "issue=$NEXT" >> "$GITHUB_OUTPUT"
# Expose to all later steps as $ISSUE_NUMBER / env.ISSUE_NUMBER.
echo "ISSUE_NUMBER=$NEXT" >> "$GITHUB_ENV"
- name: Record implementation claim
id: claim
if: steps.pick.outputs.has_work == 'true'
continue-on-error: true
timeout-minutes: 3
env:
GH_TOKEN: ${{ secrets.PAT_WORKFLOW_TRIGGER || github.token }}
run: |
set -euo pipefail
CLAIMED_AT=$(date -u +%Y-%m-%dT%H:%M:%SZ)
RUN_URL="https://github.com/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}"
CURRENT_BODY=$(gh issue view "$ISSUE_NUMBER" --json body --jq '.body // ""')
CLEAN_BODY=$(printf '%s\n' "$CURRENT_BODY" | sed '/^## Automation Claim/,$d')
cat > /tmp/issue-body.md << EOF
$CLEAN_BODY
## Automation Claim
<!-- automation-claim: {"status":"RUNNING","issue":${ISSUE_NUMBER},"run_id":${GITHUB_RUN_ID},"run_attempt":${GITHUB_RUN_ATTEMPT},"run_url":"${RUN_URL}","claimed_at":"${CLAIMED_AT}"} -->
| Field | Value |
|-------|-------|
| Status | \`RUNNING\` |
| Run | [${GITHUB_RUN_ID}](${RUN_URL}) |
| Attempt | ${GITHUB_RUN_ATTEMPT} |
| Claimed At | ${CLAIMED_AT} |
EOF
gh issue edit "$ISSUE_NUMBER" --body-file /tmp/issue-body.md
- name: Check issue still needs implementation
id: issue-state
if: steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success'
continue-on-error: true
timeout-minutes: 3
env:
GH_TOKEN: ${{ github.token }}
run: |
set -euo pipefail
ISSUE_STATE=$(gh issue view "$ISSUE_NUMBER" --json state --jq '.state')
if [ "$ISSUE_STATE" != "OPEN" ]; then
echo "Issue #$ISSUE_NUMBER is $ISSUE_STATE; skipping implementation."
echo "should_run=false" >> "$GITHUB_OUTPUT"
echo "skip_reason=issue-${ISSUE_STATE}" >> "$GITHUB_OUTPUT"
exit 0
fi
MERGED_PRS=$(gh pr list \
--repo "${{ github.repository }}" \
--state merged \
--limit 100 \
--json number,body \
| jq --arg issue "$ISSUE_NUMBER" '[.[] | select((.body // "") | test("(?i)(closes|fixes|resolves)[[:space:]]+#" + $issue + "([^0-9]|$)"))] | length')
if [ "${MERGED_PRS:-0}" -gt 0 ]; then
echo "Issue #$ISSUE_NUMBER already has a merged closing PR; skipping implementation."
echo "should_run=false" >> "$GITHUB_OUTPUT"
echo "skip_reason=merged-pr-exists" >> "$GITHUB_OUTPUT"
exit 0
fi
echo "should_run=true" >> "$GITHUB_OUTPUT"
- name: Checkout repository
if: steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true'
uses: actions/checkout@v6
with:
fetch-depth: 0
token: ${{ secrets.PAT_WORKFLOW_TRIGGER || github.token }}
- name: Install git pre-commit hook
if: steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true'
timeout-minutes: 3
run: |
cp scripts/pre-commit .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit
- name: Setup Elixir environment
if: steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true'
uses: ./.github/actions/setup-elixir
- name: Setup Claude Code
id: setup-claude
if: steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true'
uses: ./.github/actions/setup-claude-code
- name: Run tests and capture failures
id: test-feedback
if: steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true'
continue-on-error: true
timeout-minutes: 15
run: |
echo "Running tests to capture any failures..."
FAILURES=""
# Compile
echo "=== Compiling ===" | tee /tmp/test_output.txt
if ! mix compile --warnings-as-errors 2>&1 | tee -a /tmp/test_output.txt; then
FAILURES="${FAILURES}COMPILE_FAILED "
fi
# Tests (limit failures for manageable output)
echo "" >> /tmp/test_output.txt
echo "=== Running tests ===" | tee -a /tmp/test_output.txt
if ! mix test --max-failures 5 --warnings-as-errors 2>&1 | tee -a /tmp/test_output.txt; then
FAILURES="${FAILURES}TESTS_FAILED "
fi
# Format check
echo "" >> /tmp/test_output.txt
echo "=== Checking format ===" | tee -a /tmp/test_output.txt
if ! mix format --check-formatted 2>&1 | tee -a /tmp/test_output.txt; then
FAILURES="${FAILURES}FORMAT_FAILED "
fi
# Credo
echo "" >> /tmp/test_output.txt
echo "=== Running Credo ===" | tee -a /tmp/test_output.txt
if ! mix credo --strict 2>&1 | tee -a /tmp/test_output.txt; then
FAILURES="${FAILURES}CREDO_FAILED "
fi
# Capture output for Claude
if [ -n "$FAILURES" ]; then
echo "has_failures=true" >> "$GITHUB_OUTPUT"
echo "failures=$FAILURES" >> "$GITHUB_OUTPUT"
# Truncate output if too long (keep last 200 lines)
tail -200 /tmp/test_output.txt > /tmp/test_output_truncated.txt
# Store output in multiline format
{
echo 'output<<EOF'
cat /tmp/test_output_truncated.txt
echo 'EOF'
} >> "$GITHUB_OUTPUT"
echo "::warning::Test failures detected: $FAILURES"
else
echo "has_failures=false" >> "$GITHUB_OUTPUT"
echo "All checks passed"
fi
- name: Run Claude Code
id: claude
if: steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true'
timeout-minutes: 30
uses: anthropics/claude-code-action@v1
env:
GH_TOKEN: ${{ secrets.PAT_WORKFLOW_TRIGGER || github.token }}
# Used by E2E tests that call LLM APIs
OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
with:
allowed_bots: "claude"
claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
# Use PAT for git operations to avoid GitHub App workflow permission issues
github_token: ${{ secrets.PAT_WORKFLOW_TRIGGER || github.token }}
path_to_claude_code_executable: ${{ steps.setup-claude.outputs.executable-path }}
prompt: |
Implement issue #${{ steps.pick.outputs.issue }}.
## Step 1: Read Issue and Check Dependencies
```bash
gh issue view ${{ steps.pick.outputs.issue }} --comments
```
**Check for "Blocked by:" in the issue body.** If blocking issues exist:
1. Check if each blocking issue is closed: `gh issue view BLOCKER_NUMBER --json state`
2. If ANY blocker is still open:
- Post status comment (see Step 5) with result: BLOCKED
- Remove label: `gh issue edit ${{ steps.pick.outputs.issue }} --remove-label "ready-for-implementation"`
- Stop here - do not implement
## Step 2: Get Epic Context (if part of an epic)
Check issue labels for `epic:*` label. If present:
```bash
# Find the active epic
gh issue list --label "type:epic" --label "status:active" --state open --json number,title,body --limit 1
```
Read the epic to understand the broader context and what's been completed.
## Step 3: Scope Check (IMPORTANT)
Before implementing, assess whether the issue scope is appropriate:
**Signs of scope creep (STOP and report):**
- Changes spanning multiple unrelated modules or subsystems
- Discovering substantial prerequisite work not mentioned in the issue
- The implementation feels like 2-3 separate issues bundled together
- Non-mechanical changes touching areas unrelated to the issue's focus
**NOT scope creep (proceed normally):**
- Mechanical changes across many files (renames, import updates, type fixes)
- Related changes that naturally flow from the core implementation
- Test files matching the implementation scope
When stopping for scope issues:
1. Post status (see Step 6) with result: INCOMPLETE
2. Add `needs-breakdown` label and explain how to split
3. If discovered blocker:
- Create issue with `discovered-blocker` AND `needs-review` labels
- Update this issue's "Blocked by:" section
- Remove `ready-for-implementation` from this issue
## Step 4: Check for Existing PR (Duplicate Detection)
Before creating a new PR, check if one already exists:
```bash
EXISTING_PR=$(gh pr list --head "claude/${{ steps.pick.outputs.issue }}-" --state open --json number,url --jq '.[0]')
```
If a PR exists:
- Update the existing PR instead of creating a new one
- Push to the existing branch
- Post a comment noting continued work
## Step 5: Implement
${{ steps.test-feedback.outputs.has_failures == 'true' && format('### Current Test Failures
The following checks are currently failing: {0}
```
{1}
```
**Be aware of these existing failures. If related to your changes, fix them.**
', steps.test-feedback.outputs.failures, steps.test-feedback.outputs.output) || '' }}
**Guidelines:**
- Keep it simple - only implement what's requested
- Run `mix precommit` before committing - NEVER use `--no-verify`
- Create PR with "Closes #${{ steps.pick.outputs.issue }}" in body
- Use branch naming: `claude/${{ steps.pick.outputs.issue }}-short-description`
**Protected files - changes require justification:**
- `docs/specs/*.md` - Specifications (source of truth)
- `docs/guidelines/*.md` - Process documentation
- `.github/workflows/*.yml` - Automation workflows
- `.credo.exs`, `.formatter.exs` - Linter configs
If you MUST change these, explain why in the PR description.
## TODO and Skip Tag Protocol (IMPORTANT)
When you need to add TODOs, skip tests, or disable linting:
**Step 1: Search for existing issues first**
```bash
gh issue list --search "keyword describing the problem" --state open --limit 5
```
**Step 2: Create issue if none exists**
```bash
gh issue create --title "[Tech Debt] Brief description" \
--label "tech-debt" --label "from-pr-review" \
--body "Source: \`path/to/file.ex:LINE\`
Description of what needs to be fixed/cleaned up.
Found during implementation of #${{ steps.pick.outputs.issue }}."
```
**Step 3: Reference issue in code (REQUIRED)**
```elixir
# TODO(#123): Explanation of what needs to be done
# FIXME(#123): Explanation of the bug
@tag :skip # Skipped: #123 - reason why test is skipped
# credo:disable-for-next-line Credo.Check.Name - #123
```
**NEVER add TODO/FIXME/@tag :skip without an issue reference.**
## Step 6: MANDATORY Status Update (ALWAYS DO THIS)
You MUST update the issue body with automation state. This is required
even if you encounter errors or cannot complete the implementation.
First, get the current issue body, then append/update the automation state section:
```bash
# Get current body and update automation state
CURRENT_BODY=$(gh issue view ${{ steps.pick.outputs.issue }} --json body --jq '.body')
# Remove old automation state if present
CLEAN_BODY=$(echo "$CURRENT_BODY" | sed '/^## Automation State/,/^## /{ /^## Automation State/d; /^## /!d; }' | sed '/<!-- automation-state:/d')
# Create new body with automation state
cat > /tmp/issue-body.md << 'ISSUE_EOF'
$CLEAN_BODY
## Automation State
<!-- automation-state: {"status":"[SUCCESS|INCOMPLETE|BLOCKED]","pr":null,"branch":"claude/${{ steps.pick.outputs.issue }}-xxx","attempts":1} -->
| Field | Value |
|-------|-------|
| Status | `[SUCCESS\|INCOMPLETE\|BLOCKED]` |
| PR | #NNN or None |
| Branch | `claude/${{ steps.pick.outputs.issue }}-xxx` |
| Attempts | 1 |
**Details:** [What was done, what remains, blockers discovered]
**Next Steps:** [If not SUCCESS: what needs to happen]
ISSUE_EOF
gh issue edit ${{ steps.pick.outputs.issue }} --body-file /tmp/issue-body.md
```
**Status meanings:**
- SUCCESS: PR created, all work complete
- INCOMPLETE: Stopped due to scope/complexity/errors (explain why)
- BLOCKED: Open dependencies prevent implementation
NEVER include "@claude" in comments.
claude_args: '--model claude-opus-4-8 --max-turns 300 --allowed-tools "Read,Write,Edit,MultiEdit,Glob,Grep,LS,Bash,WebSearch,WebFetch,Task,TodoWrite,TodoRead"'
show_full_output: true
# Verify status was updated in issue body
- name: Verify implementation status
if: always() && steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true'
id: verify-status
timeout-minutes: 3
env:
GH_TOKEN: ${{ github.token }}
run: |
# Check if automation state exists in issue body
ISSUE_BODY=$(gh issue view "$ISSUE_NUMBER" --json body --jq '.body')
if echo "$ISSUE_BODY" | grep -q "<!-- automation-state:"; then
echo "status_posted=true" >> "$GITHUB_OUTPUT"
# Extract status from JSON
STATUS_JSON=$(echo "$ISSUE_BODY" | grep -o '<!-- automation-state: {[^}]*}' | sed 's/<!-- automation-state: //')
RESULT=$(echo "$STATUS_JSON" | grep -o '"status":"[^"]*"' | cut -d'"' -f4)
echo "result=$RESULT" >> "$GITHUB_OUTPUT"
echo "Implementation result: $RESULT"
else
echo "status_posted=false" >> "$GITHUB_OUTPUT"
echo "::warning::No automation state found in issue body"
fi
# Post fallback status if Claude didn't update issue body
- name: Post fallback status
if: always() && steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true' && steps.verify-status.outputs.status_posted == 'false'
timeout-minutes: 5
env:
GH_TOKEN: ${{ github.token }}
run: |
# Check for branch and PR
BRANCH_NAME="claude/${ISSUE_NUMBER}-"
BRANCH=$(git branch -r --list "origin/${BRANCH_NAME}*" | head -1 | tr -d ' ')
BRANCH_SHORT=$(echo "$BRANCH" | sed 's|origin/||' | tr -d ' ')
PR_NUMBER=""
if [ -n "$BRANCH_SHORT" ]; then
PR_NUMBER=$(gh pr list --head "$BRANCH_SHORT" --json number --jq '.[0].number' 2>/dev/null || echo "")
fi
# Get current issue body
CURRENT_BODY=$(gh issue view "$ISSUE_NUMBER" --json body --jq '.body')
# Remove any partial automation state
CLEAN_BODY=$(echo "$CURRENT_BODY" | sed '/^## Automation State/,$d')
# Create updated body with fallback status
cat > /tmp/issue-body.md << EOF
$CLEAN_BODY
## Automation State
<!-- automation-state: {"status":"INCOMPLETE","pr":${PR_NUMBER:-null},"branch":"${BRANCH_SHORT:-null}","attempts":1,"interrupted":true} -->
| Field | Value |
|-------|-------|
| Status | \`INCOMPLETE\` |
| PR | ${PR_NUMBER:-None} |
| Branch | \`${BRANCH_SHORT:-None}\` |
| Attempts | 1 |
**Details:** Workflow interrupted before completion (timeout or error). Check workflow logs.
**Next Steps:** Re-trigger with \`@claude Please continue implementing this issue.\`
EOF
gh issue edit "$ISSUE_NUMBER" --body-file /tmp/issue-body.md
# Add needs-attention label
gh issue edit "$ISSUE_NUMBER" --add-label "needs-attention" || true
# Safety net: push any unpushed commits and remove workflow files
- name: Push unpushed commits
if: always() && steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true'
timeout-minutes: 5
env:
GH_TOKEN: ${{ secrets.PAT_WORKFLOW_TRIGGER || github.token }}
run: |
ISSUE_STATE=$(gh issue view "$ISSUE_NUMBER" --json state --jq '.state')
if [ "$ISSUE_STATE" != "OPEN" ]; then
echo "Issue #$ISSUE_NUMBER is $ISSUE_STATE; skipping fallback push."
exit 0
fi
CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
[ "$CURRENT_BRANCH" = "main" ] && exit 0
# Re-configure git auth (Claude may have changed it)
git remote set-url origin "https://x-access-token:${GH_TOKEN}@github.com/${{ github.repository }}.git"
# Remove workflow files from any unpushed commits (GitHub App tokens can't push these)
REWROTE_COMMIT=false
if git log origin/main..HEAD --name-only --pretty=format: 2>/dev/null | grep -q "^\.github/workflows/"; then
echo "Removing workflow files from commit..."
COMMIT_MSG=$(git log -1 --format=%s)
git reset HEAD~1 --soft
git checkout origin/main -- .github/workflows/ 2>/dev/null || true
git add -A
git reset HEAD -- .github/workflows/ 2>/dev/null || true
if git commit -m "$COMMIT_MSG" 2>/dev/null; then
REWROTE_COMMIT=true
else
echo "No changes after removing workflow files"
fi
fi
# Push if there are unpushed commits
if git log origin/main..HEAD --oneline 2>/dev/null | grep -q .; then
echo "Pushing unpushed commits..."
if [ "$REWROTE_COMMIT" = "true" ]; then
echo "Using force-with-lease (commit was rewritten to remove workflow files)"
git push --force-with-lease -u origin HEAD
else
git push -u origin HEAD
fi
echo "branch_pushed=true" >> "$GITHUB_OUTPUT"
echo "branch_name=$CURRENT_BRANCH" >> "$GITHUB_OUTPUT"
echo "::notice::Pushed commits"
fi
- name: Create PR if branch was pushed but no PR exists
if: always() && steps.pick.outputs.has_work == 'true' && steps.claim.outcome == 'success' && steps.issue-state.outcome == 'success' && steps.issue-state.outputs.should_run == 'true'
timeout-minutes: 5
env:
GH_TOKEN: ${{ secrets.PAT_WORKFLOW_TRIGGER || github.token }}
run: |
ISSUE_STATE=$(gh issue view "$ISSUE_NUMBER" --json state --jq '.state')
if [ "$ISSUE_STATE" != "OPEN" ]; then
echo "Issue #$ISSUE_NUMBER is $ISSUE_STATE; skipping fallback PR creation."
exit 0
fi
CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
[ "$CURRENT_BRANCH" = "main" ] && exit 0
# Check if PR already exists for this branch
EXISTING_PR=$(gh pr list --head "$CURRENT_BRANCH" --state all --json number --jq '.[0].number')
MERGED_CLOSING_PR=$(gh pr list \
--repo "${{ github.repository }}" \
--state merged \
--limit 100 \
--json number,body \
| jq -r --arg issue "$ISSUE_NUMBER" '[.[] | select((.body // "") | test("(?i)(closes|fixes|resolves)[[:space:]]+#" + $issue + "([^0-9]|$)"))][0].number // empty')
if [ -n "$MERGED_CLOSING_PR" ]; then
echo "Merged closing PR #$MERGED_CLOSING_PR already exists; skipping fallback PR creation."
exit 0
fi
if [ -z "$EXISTING_PR" ]; then
echo "No PR exists for branch $CURRENT_BRANCH, creating one..."
# Get issue title for PR title
ISSUE_TITLE=$(gh issue view ${{ env.ISSUE_NUMBER }} --json title --jq '.title')
gh pr create \
--head "$CURRENT_BRANCH" \
--base main \
--title "$ISSUE_TITLE" \
--body "$(cat <<EOF
Closes #${{ env.ISSUE_NUMBER }}
This PR was created by the fallback mechanism after Claude's push succeeded
but PR creation failed (likely due to GitHub App permission issues).
🤖 Generated with [Claude Code](https://claude.com/claude-code)
EOF
)" || echo "::warning::Could not create PR"
else
echo "PR #$EXISTING_PR already exists for branch $CURRENT_BRANCH"
fi
# Release the claim and keep the queue draining. Runs even on failure so a
# crashed item never stays stuck as impl:running. Re-dispatch is a fast
# path; the */10 schedule is the guaranteed backstop.
- name: Release claim and drain next
if: always() && steps.pick.outputs.has_work == 'true'
timeout-minutes: 5
env:
GH_TOKEN: ${{ secrets.PAT_WORKFLOW_TRIGGER || github.token }}
run: |
set -euo pipefail
ISSUE_STATE=$(gh issue view "$ISSUE_NUMBER" --json state --jq '.state')
if [ "${{ steps.claim.outcome }}" != "success" ] || [ "${{ steps.issue-state.outcome }}" != "success" ]; then
if [ "$ISSUE_STATE" = "OPEN" ]; then
echo "Pre-implementation setup failed; requeueing issue #$ISSUE_NUMBER."
gh issue edit "$ISSUE_NUMBER" \
--remove-label "impl:running" \
--add-label "impl:queued" 2>/dev/null || true
else
echo "Pre-implementation setup failed, but issue #$ISSUE_NUMBER is $ISSUE_STATE; removing running claim."
gh issue edit "$ISSUE_NUMBER" --remove-label "impl:running" 2>/dev/null || true
fi
else
gh issue edit "$ISSUE_NUMBER" --remove-label "impl:running" 2>/dev/null || true
fi
REMAINING=$(gh issue list \
--repo "${{ github.repository }}" \
--label "impl:queued" --state open \
--json number --jq 'length')
echo "Released issue #$ISSUE_NUMBER. Queue depth now: ${REMAINING:-0}."
if [ "${REMAINING:-0}" -gt 0 ]; then
echo "Re-dispatching runner to drain next queued issue..."
gh workflow run claude-issue.yml --repo "${{ github.repository }}" \
|| echo "::warning::Self re-dispatch failed; the */10 schedule will drain the queue."
fi