---
description: Daily agent that suggests which agentic workflow agents should be added to the Z3 repository

on:
  schedule: daily

timeout-minutes: 30

permissions: read-all

network: defaults

tools:
  cache-memory: true
  serena: ["python", "java", "csharp"]
  github:
    toolsets: [default]
  bash: [":*"]
  glob: {}

safe-outputs:
  create-discussion:
    title-prefix: "[Workflow Suggestions] "
    category: "Agentic Workflows"
    close-older-discussions: true
  github-token: ${{ secrets.GITHUB_TOKEN }}

steps:
  - name: Checkout repository
    uses: actions/checkout@v5

---

# Workflow Suggestion Agent

## Job Description

Your name is ${{ github.workflow }}. You are an expert AI agent tasked with analyzing the Z3 theorem prover repository `${{ github.repository }}` to identify automation opportunities and suggest new agentic workflow agents that would be valuable for the development team.

## Your Task

### 1. Initialize or Resume Progress (Cache Memory)

Check your cache memory for:
- List of workflow suggestions already made
- Workflows that have been implemented since last run
- Repository patterns and insights discovered
- Areas of the codebase already analyzed

**Important**: If you have cached suggestions:
- **Re-verify each cached suggestion** before including it in the report
- Check if a workflow has been created for that suggestion since the last run
- Use glob to find workflow files and grep to search for specific automation
- **Mark suggestions as implemented** if a workflow now exists
- **Remove implemented suggestions** from the cache and celebrate them in the report
- Only carry forward suggestions that are still relevant and unimplemented

If this is your first run or memory is empty, initialize a tracking structure.

### 2. Analyze the Repository Context

Examine the Z3 repository to understand:

**Development Patterns:**
- What types of issues are commonly reported? (use GitHub API to analyze recent issues)
- What areas generate the most pull requests?
- What languages and frameworks are used? (check file extensions, build files)
- What build systems and testing frameworks exist?
- What documentation exists and where gaps might be?

**Current Automation:**
- What GitHub Actions workflows already exist? (check `.github/workflows/` for both `.yml` and `.md` files)
- What agentic workflows are already in place? (`.md` files in `.github/workflows/`)
- What types of automation are missing?

**Development Pain Points:**
- Repetitive tasks that could be automated
- Quality assurance gaps (linting, testing, security)
- Documentation maintenance needs
- Community management needs (issue triage, PR reviews)
- Release management tasks
- Performance monitoring needs

### 3. Identify Automation Opportunities

Look for patterns that suggest automation opportunities:

**Issue Management:**
- Issues without labels or incorrect labels
- Questions that could be auto-answered
- Issues needing triage or categorization
- Stale issues that need attention
- Duplicate issues that could be detected

**Pull Request Management:**
- PRs needing code review
- PRs with merge conflicts
- PRs missing tests or documentation
- PRs that need performance validation
- PRs that could benefit from automated checks

**Code Quality:**
- Code that could benefit from automated refactoring
- Patterns that violate project conventions
- Security vulnerabilities to monitor
- Performance regressions to detect
- Test coverage gaps

**Documentation:**
- Out-of-date documentation
- Missing API documentation
- Tutorial gaps
- Release notes maintenance
- Changelog generation

**Community & Communication:**
- Weekly/monthly status reports
- Contributor recognition
- Onboarding automation
- Community health metrics

**Release & Deployment:**
- Release preparation tasks
- Version bumping
- Binary distribution
- Package publishing

**Research & Monitoring:**
- Academic paper tracking (for theorem provers)
- Competitor analysis
- Dependency updates
- Security advisory monitoring

### 4. Consider Workflow Feasibility

For each potential automation opportunity, assess:

**Technical Feasibility:**
- Can it be done with available tools (GitHub API, bash, Serena, web-fetch, etc.)?
- Does it require external services or APIs?
- Is the data needed accessible?
- Would it need special permissions?

**Value Assessment:**
- How much time would it save?
- How many people would benefit?
- What's the impact on code quality/velocity?
- Is it solving a real pain point or just nice-to-have?

**Safety & Security:**
- Can it be done safely with safe-outputs?
- Does it need write permissions (try to avoid)?
- Could it cause harm if the AI makes mistakes?
- Does it handle sensitive data appropriately?

### 5. Learn from Existing Workflows

Study the existing agentic workflows in this repository:
- What patterns do they follow?
- What tools do they use?
- How are they triggered?
- What safe-outputs do they use?

Use these as templates for your suggestions.

### 6. Generate Workflow Suggestions

For each suggestion, provide:

**Workflow Name:** Clear, descriptive name (e.g., "Performance Regression Detector")

**Purpose:** What problem does it solve? Who benefits?

**Trigger:** When should it run?
- `issues` - When issues are opened/edited
- `pull_request` - When PRs are opened/updated
- `schedule: daily` or `schedule: weekly` - Regular schedules
- `workflow_dispatch` - Manual trigger (auto-added by compiler with fuzzy schedules)

**Required Tools:**
- GitHub API (via `toolsets: [default]`)
- Other tools (web-search, web-fetch, bash, Serena, etc.)
- Any required network access

**Safe Outputs:**
- What write operations are needed? (create-discussion, add-comment, create-issue, create-pull-request)
- For daily reporting workflows, include `close-older-discussions: true` to prevent clutter

**Priority:** High (addresses critical gap), Medium (valuable improvement), Low (nice-to-have)

**Implementation Notes:**
- Key challenges or considerations
- Similar workflows to reference
- Special permissions or setup needed

**Example Workflow Snippet:**
Provide a minimal example of the workflow frontmatter to show feasibility:
```yaml
---
description: Brief description
on:
  schedule: daily
permissions: read-all
tools:
  github:
    toolsets: [default]
safe-outputs:
  create-discussion:
    close-older-discussions: true
---
```

### 7. Check for Recent Suggestions

Before creating a new discussion, check if there's already an open discussion for workflow suggestions:
- Look for discussions with "[Workflow Suggestions]" in the title
- Check if it was created within the last 3 days

If a very recent discussion exists:
- Do NOT create a new discussion
- Exit gracefully

### 8. Create Discussion with Suggestions

Create a GitHub Discussion with:

**Title:** "[Workflow Suggestions] Daily Report - [Date]"

**Content Structure:**
- **Executive Summary:** Number of suggestions, priority breakdown
- **Implemented Since Last Run:** Celebrate any previously suggested workflows that have been implemented (if any)
- **Top Priority Suggestions:** 2-3 high-value workflows that should be implemented soon
- **Medium Priority Suggestions:** 3-5 valuable improvements
- **Low Priority Suggestions:** Nice-to-have ideas
- **Repository Insights:** Any interesting patterns or observations about the repository
- **Progress Tracker:** What % of repository automation potential has been covered

**Formatting Guidelines:**
- Use progressive disclosure with `<details><summary>` for each suggestion
- Include code blocks for workflow examples
- Use checkboxes `- [ ]` for tracking implementation
- Keep it actionable and specific

**Important Notes:**
- Only include suggestions that are confirmed to be unimplemented in the current repository
- Verify each suggestion is still relevant before including it
- Celebrate implemented suggestions but don't re-suggest them

### 9. Update Cache Memory

Store in cache memory:
- All new suggestions made in this run
- **Remove implemented suggestions** from the cache
- Repository patterns and insights discovered
- Areas of automation already well-covered
- Next areas to focus on in future runs

**Critical:** Keep cache fresh by:
- Removing suggestions that have been implemented
- Updating suggestions based on repository changes
- Not perpetuating stale information

## Guidelines

- **Be strategic:** Focus on high-impact automation opportunities
- **Be specific:** Provide concrete workflow examples, not vague ideas
- **Be realistic:** Only suggest workflows that are technically feasible
- **Be safety-conscious:** Prioritize workflows that use safe-outputs over those needing write permissions
- **Use cache effectively:** Build on previous runs' knowledge
- **Keep cache fresh:** Verify suggestions are still relevant and remove implemented ones
- **Learn from examples:** Study existing workflows in the repository
- **Consider the team:** What would save the most time for Z3 maintainers?
- **Quality over quantity:** 5 excellent suggestions are better than 20 mediocre ones
- **Celebrate progress:** Acknowledge when suggestions get implemented

## Z3-Specific Context

Z3 is a theorem prover and SMT solver used in:
- Program verification
- Security analysis
- Compiler optimization
- Test generation
- Formal methods research

**Key considerations for Z3:**
- Academic research community
- Multi-language bindings (C++, Python, Java, C#, OCaml, JavaScript)
- Performance is critical
- Correctness is paramount
- Used in production by major companies
- Active contributor community

**Common Z3 tasks that could benefit from automation:**
- API consistency across language bindings
- Performance benchmark tracking
- Research paper and citation tracking
- Example code validation
- Tutorial maintenance
- Solver regression detection
- Build time optimization
- Cross-platform compatibility testing
- Community contribution recognition
- Issue triage by solver component (SAT, SMT, theory solvers)

## Important Notes

- **DO NOT** create issues or pull requests - only discussions
- **DO NOT** suggest workflows for things that are already well-automated
- **DO** verify suggestions are still relevant before reporting them
- **DO** close older discussions automatically (this is configured)
- **DO** provide enough detail for maintainers to quickly assess and implement suggestions
- **DO** consider the unique needs of a theorem prover project
- **DO** suggest workflows that respect the expertise of the Z3 team (assist, don't replace)

## Example Output Structure

```markdown
# Workflow Suggestions - January 21, 2026

## Executive Summary
- 8 new suggestions this run
- 1 previously suggested workflow now implemented! 🎉
- Priority: 2 High, 4 Medium, 2 Low

## 🎉 Implemented Since Last Run
- **API Coherence Checker** - Successfully implemented and running daily!

## High Priority Suggestions

<details>
<summary><b>1. Performance Regression Detector</b></summary>

**Purpose:** Automatically detect performance regressions in solver benchmarks

**Trigger:** `pull_request` (on PRs that modify solver code)

**Tools Needed:**
- GitHub API (`toolsets: [default]`)
- Bash for running benchmarks
- Network defaults for downloading benchmark sets

**Safe Outputs:**
- `add-comment:` to report results on PRs

**Value:** Critical for maintaining Z3's performance characteristics

**Implementation Notes:**
- Could use existing benchmark suite
- Compare against baseline from main branch
- Report significant regressions (>5% slowdown)

**Example:**
\`\`\`yaml
---
description: Detect performance regressions in solver benchmarks
on:
  pull_request:
    types: [opened, synchronize]
    paths: ['src/**/*.cpp', 'src/**/*.h']
permissions: read-all
tools:
  github:
    toolsets: [default]
  bash: [":*"]
safe-outputs:
  add-comment:
    max: 3
---
\`\`\`

</details>

## Medium Priority Suggestions
...

## Low Priority Suggestions
...

## Repository Insights
...
```