Upstream Branch Sync
Rebase a stale session branch onto the latest upstream changes.
The skill defines fetching upstream and rebasing, and explicitly says upstream wins during conflicts, providing some operational scope. It does not require user confirmation, disclose the remote data flow, provide a backup or abort/rollback procedure, or address failed partial rebases; automatically committing uncommitted work also creates local state changes, so trust is substantially deducted.
The main workflow is short and internally understandable, including staging resolved files and continuing the rebase. However, it lacks diagnosable handling for unavailable remotes, authentication failure, nonstandard branches, commit failure, unresolvable conflicts, and failed validation; validation is also vague. Static calibration therefore keeps the score below 10.
The name, description, and workflow fit the scenario of a stale session branch catching up with a significantly advanced upstream. Boundaries, non-trigger cases, required repository state, remote prerequisites, and expected outputs are not specified, Chinese-language support is absent, and reachability of the required Git remote is not established, so points are deducted.
The document has front matter and sections for workflow, conflict handling, and validation. Repository-level material supplies MIT licensing, Microsoft attribution, and maintenance context. The skill itself lacks versioning, changelog, ownership/update responsibility, installation and dependency notes, examples, FAQs, explicit limitations, and a clear update path; it also assumes a separate /commit skill.
The stated goal—rebasing the current session branch onto current upstream—could plausibly be achieved on the happy path. Nevertheless, automatic commit/rebase effects require review, validation has no concrete acceptance commands, and the skill does not produce a clearly defined recoverable result when session work no longer fits. Static calibration limits this to the 7-point range.
The instructions expose auditable commands and conflict policy, while the repository includes general CI and test material. That evidence is not specific to this skill's rebase path, and no skill-specific tests, sample outputs, or third-party execution evidence are provided, so verifiability remains limited.
- Obtain explicit confirmation before committing automatically, fetching from the remote, or resolving conflicts in a way that may discard session-side changes; create a recoverable branch or backup first.
- Add concrete handling and failure feedback for origin/base-branch discovery, authentication or network failure, unresolvable conflicts, abort/recovery, commit failure, and validation failure.
- Specify executable validation commands and acceptance criteria tied to the session objective; the supplied repository CI evidence does not demonstrate that this skill path is tested.
What does this skill do, and when should you use it?
This skill updates a session branch that has fallen behind origin. It first handles uncommitted changes, then fetches upstream and rebases the current branch onto the appropriate base branch, with origin/main as the documented example. When conflicts occur, upstream logic is preserved and session work is adapted around it. After the rebase, the result should be checked for compilation and alignment with the session’s objectives.
Checks for uncommitted changes and, when necessary, uses the /commit skill to commit them; runs git fetch origin; runs git rebase origin/main, or uses the appropriate branch when the base is not main; resolves conflicts by preserving upstream logic, adapting session work, staging files with git add, and continuing with git rebase --continue; then validates compilation and session objectives.
- A developer’s session branch is substantially behind origin and needs to catch up before further work.
- A developer encounters rebase conflicts where upstream behavior and APIs must take precedence.
- A developer wants to verify that session changes still compile and meet their objectives after synchronization.
What are this skill's strengths and limitations?
- Defines a clear upstream-first conflict-resolution policy.
- Covers local-change handling, fetching, rebasing, conflict continuation, and post-rebase validation.
- Targets a concrete Git workflow for keeping session branches aligned with origin.
- Requires Git, network access, and local filesystem access.
- Does not specify exact build or test commands for validation.
- Conflict resolution may require rewriting session work to fit upstream changes.
How do you install this skill?
The README says the repository bundles 61 skills, but it does not document a standalone installation command or destination. This skill is located at src/vs/sessions/skills/sync-upstream/SKILL.md.
How do you use this skill?
Invoke it when the session branch is stale, for example: "Rebase the current session branch onto the latest upstream and resolve conflicts in favor of upstream." The documented workflow uses git fetch origin and git rebase origin/main; use the appropriate base branch if it is not main.