operation-git

Centralized git + GitHub operations. We follow GitHub Flow: main is protected and always deployable, and all feature work happens on short-lived branches that merge back via pull request. Workflow skills (workflow-e2e-*, workflow-engineer-*, workflow-reviewer-*), the implement-slice Workflow script, and the /implement-feature command never duplicate gh / git plumbing — they call the scripts under this skill's scripts/ directory. (Outer-loop candidate discovery for /implement-feature lives entirely as scripts here too — task-finder.sh + the four stage scripts: reconcile (0), kickoff-slice (1), fix-pr (8), close-pr (9) — with no agent or skill layer in between. The inner slice cycle runs inside the per-slice implement-slice Workflow, not here.)

When to activate

Activate this skill whenever the user:

• Asks for help writing a commit message, branch name, PR title/body, or issue.
• Is about to create, name, or push a branch — including worktrees.
• Wants to open, update, or merge a pull request.
• Wants to create or label an issue, link a blocker, or close one.
• Is preparing a release, bumping a version, or tagging.
• Edits or creates a .gitignore.
• Asks "how do I do X with gh" or wants the standard GitHub CLI invocation for a task.

Also load this skill implicitly from inside any workflow-* skill that needs to mutate GitHub state — the workflow-* skill drives the workflow, this skill owns the primitives.

Do NOT activate when the user is asking about git internals unrelated to our workflow (e.g. "explain how rebase works"), or when they are working in a non-GitHub host (GitLab, Bitbucket) — the conventions here assume GitHub Flow + gh.

Label scheme

The Automated Engineer Flow drives off a deliberately small label set — the inner slice cycle runs inside one implement-slice Workflow per slice, so everything that used to round-trip through labels (per-task typing, the review gate family, the e2e markers, the level split) is now in-memory workflow state or lives in the slice body's task checklist. The init-flow-labels.sh script creates the survivors and DELETES the retired labels, idempotently.

There are no level:*, type:*, review:*, or e2e:* labels — those were retired by the per-slice-Workflow redesign. Task typing and per-task done-state live in the slice body's ## Tasks static-ID checklist; review/coverage gating is an in-memory phase of the implement-slice Workflow.

References and scripts

When this skill is active, route to the asset that matches the task. Read references on demand; invoke scripts via bash skills/operation-git/scripts/<name>.sh ... (or directly — they are executable).

References

Worktree + slice resolution

Candidate listing (workflow orchestrators)

Each script lists open issues / PRs matching a specific workflow stage. All return JSON; the caller iterates.

Lifecycle discovery (driven by /implement-feature)

Pure shell — no LLM, no agent, no skill layer. The umbrella driver runs the four stage scripts against ONE GitHub-state snapshot and emits the canonical markdown report /implement-feature parses positionally. Each stage script's header comment documents its line format and gate set. (Stages 2–7 were retired — the inner slice cycle they covered now runs inside the per-slice implement-slice Workflow.)

Lifecycle discovery (driven by /ship — all three kinds)

Pure shell, same shape as the task-finder family but covering feature + enhancement + bug with an optional milestone (omit it for the repo-wide maintenance lane). ship-finder.sh runs five named stages against ONE snapshot and emits a # ship-finder report the /ship command parses by stage name. The /implement-feature task-finder family above is left intact as a feature-only fallback.

Label flipping (atomic)

Reviewer outputs

Release / repo setup

Templates

Pattern

.gitignore baseline

Start every repo with at least these entries; add language/framework-specific entries on top.

# Dependencies
node_modules/
vendor/

# Build outputs
dist/
build/
*.o
*.exe

# Environment files
.env
.env.local
.env.*.local

# IDE
.idea/
.vscode/
*.swp
*.swo

# OS files
.DS_Store
Thumbs.db

# Logs
*.log
logs/

# Test coverage
coverage/

# Cache
.cache/
*.tsbuildinfo

Anti-patterns

• Committing directly to main → always branch + PR.
• Committing secrets (.env, keys) → add to .gitignore, use env vars / secret managers.
• Giant PRs (1000+ lines) → split into smaller, focused PRs.
• "update" / "fix" / "WIP" commit messages → use Conventional Commits with context.
• Force-pushing to main or shared branches → use git revert to undo public history.
• Long-lived feature branches (weeks/months) → keep branches short, rebase on main often.
• Committing generated files (dist/, node_modules/) → add to .gitignore.
• Bypassing the workflow scripts to call gh directly from a workflow-* skill → call scripts/<name>.sh instead so behavior stays consistent across skills.