[CI Failure Doctor] Check Go formatting step failed - code not properly formatted

[github-actions]

🏥 CI Failure Investigation - Run #20984232736

Summary

The CI workflow failed because Go code was not properly formatted before committing. The "Check Go formatting" step in the lint-go job detected unformatted code.

Failure Details

• Run: #20984232736
• Commit: b1b5f4b
• Trigger: push to main
• PR: Fix MCP Gateway v0.0.47+ schema validation in metrics-collector workflow #9903 - "Fix MCP Gateway v0.0.47+ schema validation in metrics-collector workflow"
• Duration: 2.8 minutes
• Failed Job: lint-go (Job ID: 60315087487)
• Failed Step: Step 5 - "Check Go formatting"

Root Cause Analysis

The commit modified workflow files (.github/workflows/metrics-collector.lock.yml and .github/workflows/metrics-collector.md) but Go code in the repository was not properly formatted according to go fmt standards before the commit was pushed.

The CI workflow includes a formatting check that runs:

unformatted=$(go fmt ./...)
if [ -n "$unformatted" ]; then
  echo "❌ Code is not formatted. Run 'make fmt' to fix."
  exit 1
fi

This check detected that running go fmt ./... would modify files, indicating they were not properly formatted.

Files Changed in Failing Commit

• .github/workflows/metrics-collector.lock.yml (+7/-10 lines)
• .github/workflows/metrics-collector.md (+0/-1 lines)

Failed Jobs and Errors

lint-go (Job ID: 60315087487)

• Failed Step: Check Go formatting (Step 5)
• Error: go fmt detected unformatted Go code
• Root Cause: Code was committed without running make fmt or go fmt ./... first

All subsequent steps were skipped:

• Install golangci-lint (skipped)
• Run golangci-lint (skipped)
• Lint error messages (skipped)

Recommended Actions

Immediate Fix

1. Run formatting: make fmt
2. Recompile workflows: make recompile
3. Commit the formatting changes
4. Push to main branch

For Future Commits

ALWAYS run before committing:

make agent-finish  # Runs build, test, recompile, fmt, lint (~10-15s)

Or at minimum:

make fmt           # Format Go code
make recompile     # Recompile workflow lock files (if workflows changed)

Prevention Strategies

Current Documentation Issues

The repository's AGENTS.md file states:

ALWAYS RUN AGENT-FINISH BEFORE COMMITTING:

make agent-finish  # Runs build, test, recompile, fmt, lint

However, this requirement was not followed in PR #9903, suggesting:

1. The AI agent (Copilot) did not follow the documented workflow
2. Pre-commit checks may not be enforced
3. The requirement needs to be more prominent in the workflow

Recommended Improvements

1. Add pre-commit git hooks to automatically run make fmt
2. Update GitHub Actions to run formatting checks on PRs before merge
3. Enhance AI agent instructions with stricter formatting requirements
4. Add automated reminders in PR templates about running make agent-finish

AI Team Self-Improvement

Additional Prompting Instructions for AI Coding Agents

BEFORE EVERY COMMIT, you MUST:

1. Run formatting: make fmt (formats Go code using go fmt ./...)
2. Run recompile: make recompile (recompiles all workflow lock files)
3. Run complete validation: make agent-finish (runs build, test, recompile, fmt, lint)

These are NOT optional - they are MANDATORY steps.

Why This Matters

The CI workflow has a "Check Go formatting" step that runs go fmt ./... and fails the build if ANY files would be changed. This means:

• ❌ If you skip make fmt, your PR will fail CI
• ❌ If you modify workflow files without make recompile, your PR will fail CI
• ✅ The only way to prevent CI failures is to run these commands BEFORE committing

Failure Pattern Detection

If you see CI failures with:

• Failed job: "lint-go"
• Failed step: "Check Go formatting"
• Error message: "Code is not formatted. Run 'make fmt' to fix."

This means someone committed code without running formatting. The fix is:

make fmt
git add .
git commit --amend --no-edit
git push --force-with-lease

Commit Checklist for AI Agents

Before every commit:

• Run make fmt - Format all Go code
• Run make recompile - Recompile workflow lock files (if workflow files changed)
• Run make lint - Check for linting errors
• Run make test-unit - Run unit tests
• Run make agent-finish - Complete validation (recommended)

If you skip these steps, your commit WILL fail CI and waste time.

Historical Context

This is a code quality enforcement failure, not a recurring pattern. The repository has clear documentation about running make agent-finish before commits, but this requirement was not followed in PR #9903.

Pattern Signature: GO_FORMAT_CHECK_FAILED
Severity: Medium
Is Flaky: No
Is Recurring: No
Fix Urgency: Medium

Investigation Notes

• Category: Code Quality - Formatting
• Type: Go Code Formatting Check Failed
• Impact: CI failure blocks the main branch until formatting is fixed
• Time to Fix: ~5 minutes (run make fmt, commit, push)
• Preventable: Yes - following documented pre-commit workflow prevents this

This failure is straightforward and easily preventable by following the repository's documented workflow. The issue highlights the need for better enforcement of pre-commit formatting checks, either through git hooks or automated reminders.

AI generated by CI Failure Doctor

To add this workflow in your repository, run gh aw add githubnext/agentics/workflows/ci-doctor.md@ea350161ad5dcc9624cf510f134c6a9e39a6f94d. See usage guide.

[github-actions]

🔄 Duplicate Failure Detected - Run #20984290612

This is a second occurrence of the same formatting failure pattern, just 6 minutes after the first one.

Current Failure Details

• Run: #20984290612
• Commit: 99c636f2c951217ad7e47e1e94c290a3732bed18
• PR: Refactor strings_test.go to use testify assertions #9894 - "Refactor strings_test.go to use testify assertions"
• Time: 2026-01-14T06:14:00Z (6 minutes after previous failure)
• Author: Copilot (same as previous failure)

What Changed

The commit refactored pkg/workflow/strings_test.go to use testify assertions:

• ✅ Good: Replaced manual equality checks with assert.Equal()
• ✅ Good: Added github.com/stretchr/testify/assert import
• ❌ Problem: File was not formatted with go fmt before commit

Files Modified

• pkg/workflow/strings_test.go (+10/-30 lines)

Root Cause (Same as Before)

The Copilot agent made a legitimate code improvement but skipped the mandatory make fmt step before committing. This is the exact same failure pattern as the previous occurrence (run #20984232736).

Pattern Analysis

This is now a RECURRING pattern:

• Frequency: 2 failures in 6 minutes
• Common factor: Both commits by Copilot agent
• Common failure: Both skipped make fmt before commit
• Pattern signature: GO_FORMAT_CHECK_FAILED

Immediate Fix Required

make fmt
git add .
git commit -m "Fix Go formatting in strings_test.go"
git push

Critical Observation

The fact that two separate PRs (#9903 and #9894) both failed with the same formatting issue within 6 minutes suggests that:

1. ⚠️ The Copilot agent is not consistently following the documented pre-commit workflow
2. ⚠️ The make agent-finish requirement in AGENTS.md is being ignored
3. ⚠️ There is no automated enforcement mechanism (pre-commit hooks, GitHub Actions check)

Recommendation: Urgent Process Fix

Given this recurring pattern, I recommend:

1. Immediate: Add a pre-commit git hook that automatically runs make fmt
2. Short-term: Update CI to fail PRs earlier (before merge) if formatting is wrong
3. Long-term: Modify Copilot agent instructions to make make agent-finish a blocking requirement
4. Monitoring: Track future occurrences to see if this pattern continues

Investigation Files

Both investigations have been saved to the pattern database:

• /tmp/gh-aw/cache-memory/investigations/2026-01-14-20984232736.json
• /tmp/gh-aw/cache-memory/investigations/2026-01-14-20984290612.json
• /tmp/gh-aw/cache-memory/patterns/go_format_check_failed.json

---

🤖 Investigation by CI Failure Doctor

Pattern detected: GO_FORMAT_CHECK_FAILED (2 occurrences)

AI generated by CI Failure Doctor

[github-actions]

🔄 Pattern Recurrence Alert - THIRD Formatting Failure Today

Run: #20984405453
Commit: 7095a53
PR: #9896 - "Consolidate duplicate wildcard validation across safe output parsers"
Time: 2026-01-14 06:18:52Z (4 minutes after the second failure)

---

🚨 Critical Pattern Identified

This is now the THIRD formatting failure in 10 minutes, all from Copilot AI agents:

1. 06:08:42Z - Run 20984232736 (PR Fix MCP Gateway v0.0.47+ schema validation in metrics-collector workflow #9903) - Modified workflow files
2. 06:14:00Z - Run 20984290612 (PR Refactor strings_test.go to use testify assertions #9894) - Refactored test file with testify
3. 06:18:52Z - Run 20984405453 (PR Consolidate duplicate wildcard validation across safe output parsers #9896) - THIS FAILURE - Added helper function

What Went Wrong This Time

PR #9896 consolidated duplicate wildcard validation logic:

• ✅ Good: Added new helper function validateTargetRepoSlug() to pkg/workflow/config_helpers.go
• ✅ Good: Refactored 7 files to use the new helper (DRY principle)
• ❌ Bad: Did NOT run make fmt before committing
• ❌ Bad: The new function in config_helpers.go has formatting issues

Files Changed:

• pkg/workflow/config_helpers.go (+13 lines) - NEW FUNCTION, NOT FORMATTED
• pkg/workflow/add_comment.go (refactored to use helper)
• pkg/workflow/add_reviewer.go (refactored to use helper)
• pkg/workflow/close_entity_helpers.go (refactored to use helper)
• pkg/workflow/create_discussion.go (refactored to use helper)
• pkg/workflow/create_issue.go (refactored to use helper)
• pkg/workflow/create_pull_request.go (refactored to use helper)

Root Cause

The refactoring itself is excellent - it eliminates code duplication and improves maintainability. However, the new helper function was not formatted with go fmt before commit, causing the CI formatting check to fail.

Why This is Critical

Three failures in 10 minutes from the same AI agent (Copilot) indicates:

• ❌ make agent-finish is being systematically skipped
• ❌ Pre-commit validation is not being enforced
• ❌ The documented workflow is not being followed

This is NOT random - this is a pattern that needs immediate attention.

Immediate Actions Needed

1. Fix this failure (same as previous):

   make fmt
   git add .
   git commit -m "Fix formatting in config_helpers.go"
   git push

2. Strengthen AI agent enforcement:

   • Update .github/agents/developer.instructions.md with MANDATORY pre-commit checks
   • Consider adding automated pre-commit hooks
   • Add CI check to block PRs that don't pass formatting

3. Root cause investigation:

   • Why is Copilot consistently skipping make agent-finish?
   • Is the instruction not visible enough in the agent's context?
   • Is there a workflow gap that allows commits without validation?

Pattern Signature

Pattern: GO_FORMAT_CHECK_FAILED_SYSTEMATIC
Severity: HIGH (was medium, now upgraded due to recurrence)
Is Recurring: YES (3 occurrences in 10 minutes)
Fix Urgency: URGENT (systematic issue, not isolated incident)

---

Investigation Data

Full investigation saved to cache:

• /tmp/gh-aw/cache-memory/investigations/2026-01-14-20984405453.json
• Related: 2026-01-14-20984232736.json, 2026-01-14-20984290612.json

This issue should remain OPEN until the systematic pattern is addressed, not just the immediate formatting fix.

---

AI generated by CI Failure Doctor

AI generated by CI Failure Doctor

[github-actions]

🔄 Duplicate Failure Detected - Run #20986559929

This is the FOURTH occurrence of the same Go formatting failure pattern on 2026-01-14.

Latest Failure Details

• Run: #20986559929
• Time: 07:51 UTC
• Commit: a77d3d1
• PR: Add views property to update-project frontmatter configuration #9907 - "Add views property to update-project frontmatter configuration"
• Failed Job: lint-go → Check Go formatting step

Files Modified (Not Formatted)

pkg/workflow/compiler_safe_outputs_specialized.go (+9 lines)
pkg/workflow/update_project.go (+71 lines)
pkg/workflow/update_project_job.go (+10 lines)

Pattern Timeline Today (2026-01-14)

#	Time	Run ID	PR	Status
1	06:08	20984232736	#9903	Issue #9913 created
2	06:14	20984290612	#9894	Investigated
3	06:18	20984405453	#9896	Investigated
4	07:51	20986559929	#9907	THIS FAILURE

Root Cause (Unchanged)

Copilot AI agent completed the PR successfully but did not run make agent-finish before committing. The code changes are functionally correct but violate the mandatory formatting requirements.

Why This Keeps Happening

The AI agent workflow is not enforcing the documented pre-commit requirement to run make agent-finish. This is a systematic gap, not individual mistakes.

Immediate Actions Needed

For This Specific Failure:

make fmt           # Fix formatting
git add .
git commit -m "Fix Go formatting in project views code"
git push

For The Pattern:

1. ⚠️ Update AI agent instructions to make make agent-finish non-optional
2. ⚠️ Add pre-commit validation in the agent workflow
3. ⚠️ Block PR merges if formatting check fails
4. ⚠️ Consider automated formatting in PR workflows

This pattern is creating significant CI noise and blocking the main branch multiple times per day.

---

Investigation stored: /tmp/gh-aw/cache-memory/investigations/2026-01-14-20986559929.json

AI generated by CI Failure Doctor