安全公关工作流程

工程开发 社区

技能解读

当前原文的自动摘译,尚未人工审校。

概述

引导用户完成 GitHub 优先的 PR 工作流程,保持 main 干净,无需频繁的本地变基。更喜欢短期的功能分支,在同步时将origin/main合并到功能分支中,并使用Squash and merge进行更改。偏重安全而非优雅。选择可逆操作,避免重写共享历史记录,并在工作时分小步教导用户。

安全默认值

将main和master视为共享的敏感分支。为每项任务使用短期功能分支。假设推送的分支或开放的 PR 可能已经被共享。在任何同步、合并或恢复操作之前首选git fetch。更喜欢将 origin/main 合并到功能分支中,而不是对其进行变基。

首先检查

在任何更改历史记录、分支或远程状态的 Git 操作之前,请检查:当前分支以及它是否是默认分支干净与脏工作树上游跟踪分支以及是否推送本地提交该分支是否具有开放的 PR 或者显示为共享

标准工作流程

使用此作为低经验用户的默认 GitHub 工作流程:来自main的分支。以小的逻辑步骤在功能分支上进行本地提交。尽早打开 PR。当分支落后于main时,将origin/main合并到功能分支中。

开放 PR

当帮助用户打开 PR 时,请将 PR 标题视为可能的最终压缩合并提交。写出标题,以便在 Squash and merge 之后的 main 上易于阅读。当存储库使用该约定时,请使用简洁的约定提交样式标题。描述最终结果,而不是实施过程或审查过程。避免使用诸如WIP、fix stuff、address comments或update branch之类的标题。

流狐档案 运行与权限由流狐静态检查推断,不代表作者声明或实际测试结果。
领域
工程开发
作者声明的智能体
未找到明确声明;不据此推断已兼容或已测试
静态检查
88 / 100 · 启发式扫描,不代表运行安全
运行环境证据
未执行;当前没有隔离运行测试证据
作者 / 版本 / 许可证
@tomevault-io · 未声明许可证
上下文用量评级
低消耗
接入复杂程度
即装即用
是否需要外部接口密钥
不需要
兼容的系统
未声明(默认跨平台)
运行环境要求
未检出明确要求
检测到的文件与系统行为
  • 只读
  • 允许写入 / 修改
网络行为
允许外网请求
安装命令数
无(仅作为资料)

需要注意: 未声明工具权限范围;实际权限由运行环境决定。

作者说明文件(原文) SKILL.md

# Git Safe Pr Workflow

## Overview

Guide users through a GitHub-first PR workflow that keeps `main` clean without requiring
frequent local rebases. Prefer short-lived feature branches, merge `origin/main` into the
feature branch when syncing, and land changes with `Squash and merge`.

Bias toward safety over elegance. Choose reversible operations, avoid rewriting shared
history, and teach the user in small steps while you work.

## Safe Defaults

- Treat `main` and `master` as shared, sensitive branches.
- Use a short-lived feature branch for every task.
- Assume a pushed branch or open PR may already be shared.
- Prefer `git fetch` before any sync, merge, or recovery action.
- Prefer merging `origin/main` into a feature branch over rebasing it.
- Prefer `git revert` over rewriting history when commits may already be pushed.
- Prefer `Squash and merge` to keep `main` clean.

## Inspect First

Before any Git operation that changes history, branches, or remote state, inspect:

- current branch and whether it is the default branch
- clean vs dirty working tree
- upstream tracking branch and whether local commits are pushed
- whether the branch has an open PR or appears shared
- staged and unstaged diff when undoing or syncing work

If you cannot determine whether a branch is shared, assume it is shared and choose the
safer path.

## Standard Workflow

Use this as the default GitHub workflow for low-experience users:

1. Branch from `main`.
2. Commit locally on the feature branch in small logical steps.
3. Open a PR early.
4. When the branch falls behind `main`, merge `origin/main` into the feature branch.
5. Resolve conflicts carefully and verify the final code, not just the merge markers.
6. Push the updated branch.
7. Merge with `Squash and merge`.
8. Delete the feature branch after merge.

Do not teach users to routinely rebase pushed PR branches just to get the latest `main`.
That workflow is where many novices re-introduce old code or lose work.

## Opening PRs

When helping a user open a PR, treat the PR title as the likely final squash-merge commit.

- Write the title so it reads well on `main` after `Squash and merge`.
- Use a concise Conventional Commit style title when the repo uses that convention.
- Describe the final outcome, not the implementation journey or review process.
- Avoid titles like `WIP`, `fix stuff`, `address comments`, or `update branch`.

Good default patterns:

- `feat: add <skill-name> skill`
- `feat(<skill-name>): add <capability>`
- `fix(<skill-name>): correct <problem>`
- `docs: document <policy or workflow>`

For the PR body:

- briefly state what changed
- briefly state why it changed
- mention testing or validation if relevant

If the repo uses GitHub squash merges, prefer the PR title as the default squash commit message.

## Sync Decision Tree

- **Need the latest `main` on a feature branch?** Use `fetch`, then merge `origin/main` into the
  feature branch.
- **Need a clean `main` history?** Rely on `Squash and merge`, not local rebasing of the feature
  branch.
- **Need to clean up unpublished local commits?** Rebase is acceptable only if the branch is
  clearly private, unpublished, and not under review.
- **Need to undo pushed work?** Use `revert`.
- **Need to discard local-only work?** Use the least destructive local undo that matches the goal.

If a user asks to rebase a pushed branch, explain why that is risky and propose merging
`origin/main` instead.

## Conflict Resolution Rules

- Resolve conflicts to the desired final code state, not by blindly taking both sides.
- Assume old bugs can be reintroduced during conflict resolution.
- After resolving conflicts, inspect the affected files and summarize what changed.
- Run targeted verification after conflicts: tests, build, or focused checks in the touched area.
- If the resolution is non-obvious, explain it briefly to the user while making the change.

For detailed conflict-handling steps and examples, read `references/conflict-resolution.md`.

## Recovery Rules

- If a merge is in progress and the user wants to stop, abort the merge rather than improvising.
- If a rebase is in progress and has gone wrong, stop and recover with `reflog` or rebase abort.
- If the wrong commit was pushed, prefer `revert`.
- If work was committed to the wrong branch, preserve it and move it rather than deleting it.
- When recovering history, explain what reference point you are returning to and why.

For recovery playbooks, read `references/recovery.md`.

## Refuse or Warn Hard

- Do not commit directly to `main` unless the user explicitly asks and the repo policy allows it.
- Do not force-push `main` or other protected branches.
- Do not rebase a pushed/shared branch by default.
- Do not use `git reset --hard`, `git clean -fd`, branch deletion, or tag deletion unless the user
  clearly wants destructive cleanup.
- Do not bypass branch protections, required checks, or required review flows.

If the user explicitly wants a risky operation, explain the safer alternative first. Only proceed
when the request is clear and the branch is not a protected/shared branch.

## Teaching Behavior

Teach in short, repeatable notes while working:

- State what you are about to do and why it is the safer path.
- When rejecting rebase, explain that rebase rewrites commit history and is easy to misuse once
  a branch is pushed.
- When merging `origin/main`, explain that this preserves the branch's existing commits and is
  easier to recover from.
- After recovery, explain what went wrong, how you recovered, and what safer habit to use next time.
- Avoid long Git lectures. Teach the next decision, not the whole tool.

## GitHub Settings To Recommend

When asked how to support this workflow at the repo level, recommend:

- protect `main`
- require pull requests before merge
- require status checks
- require at least one review
- enable `Squash and merge`
- disable `Rebase and merge`
- optionally disable regular merge commits if the team wants squash-only history
- set the default squash commit message to `Pull request title`
- auto-delete head branches after merge

For repo policy details, read `references/repo-settings.md`.

## Quick Checklist

Before syncing a feature branch:

- [ ] confirm you are on the feature branch, not `main`
- [ ] fetch remote changes
- [ ] check for uncommitted work
- [ ] merge `origin/main`, do not rebase by default
- [ ] inspect and verify conflict resolutions

Before pushing:

- [ ] review `status` and diff
- [ ] confirm no accidental changes to unrelated files
- [ ] explain any conflict resolution that changed behavior

Before undoing:

- [ ] determine whether the commits are pushed
- [ ] choose `revert` for pushed work
- [ ] use local-only undo only for unpublished work

---
> Source: [caidanw/skills](https://github.com/caidanw/skills) — distributed by [TomeVault](https://tomevault.io).
<!-- tomevault:4.0:skill_md:2026-05-22 -->

讨论

基于 GitHub Discussions。登录 GitHub 即可参与讨论、点赞、订阅更新。