GitLabgitlab-org

cli

main
ply10 git calls204 ms102 KiB8 cachedprotocol v2
177 lines11 KiBRaw

glab stack

glab stack is a feature of the GitLab CLI for managing stacked diffs: small, dependent changes that build on each other to deliver a larger feature. Each diff in the stack is a separate branch with its own MR. Reviewers see only the changes in their diff; you keep building while earlier changes are in review.

Status: Experiment, released in GitLab CLI v1.42.0. The interface may change.

How glab stack works

glab stack uses a save-centric model: glab stack save bundles staging, committing, and branch creation into a single step. There are no separate Git operations for creating stack branches — the CLI manages branch creation automatically. Stack metadata lives in .git/stacked/ in the repo.

Each diff gets its own branch named {branch_prefix}-{stack-title}-{8-char-hex}. The branch prefix defaults to the current user's username (from os/user.Current), falling back to glab-stack if unavailable; it can also be set with glab config set branch_prefix <value>. The hash is generated at save time from the message, title, author, and timestamp — branch names are not sequential or predictable in advance. Use glab stack list to see the current branch names for each diff.

text
main (default branch)
 └── karmstrong-add-auth-5b337685  →  MR !1 (targets main)              ← first diff (oldest)
  └── karmstrong-add-auth-74f87791 →  MR !2 (targets karmstrong-add-auth-5b337685)
   └── karmstrong-add-auth-c3a91b02 → MR !3 (targets karmstrong-add-auth-74f87791) ← last diff (newest)

Stack names are sanitized on creation: spaces and special characters are replaced with dashes. The name "add auth feature" becomes add-auth-feature. Always use the sanitized form with glab stack switch.

You can have multiple named stacks per repo and switch between them with glab stack switch.

When to use stacks

Stacks work well when:

  • A feature is large enough that a single MR would be hard to review
  • Changes have a clear dependency order — data layer feeds the API layer feeds the UI
  • You want to unblock reviewers on completed diffs while you keep building
  • Feedback on one diff shouldn't block progress on the diffs after it

Each diff should represent a discrete, logical concern that can be reviewed independently. A reviewer reading the MRs in sequence should understand the progression as a cohesive story.

Agent rules

These commands launch interactive TUIs or prompt for input — they hang or fail without a TTY:

  • ❌ glab stack move — fuzzy-finder for selecting a diff; agents cannot interact with it
  • ❌ glab stack reorder without arguments — opens a text editor to reorder diffs, or fails without a TTY; pass branch names in order instead (glab stack reorder <branch>...)
  • ❌ glab stack infer without --all — opens a text editor to select commits, or fails without a TTY; pass --all instead (glab stack infer --all <revision-range>)
  • ❌ glab stack save without -m — prompts interactively for a commit message if none is provided
  • ❌ glab stack amend without -m — prompts interactively for a description if none is provided
  • ❌ glab stack create without a name argument — may prompt

Always do the following:

  1. Always pass -m to save and amend. This is the most common footgun — without it, the CLI prompts interactively and hangs.
  2. Use glab stack list to inspect the stack, not glab stack move. list is non-interactive; move is not usable by agents.
  3. Navigate with first, last, prev, next. These are all non-interactive. Do not use move for navigation.
  4. Pass an explicit name to glab stack switch. Stack names are the directory names under .git/stacked/. Note: switch only changes the active stack in config — it does not check out any branch. After switching, use glab stack last (or first, next, etc.) to move to a diff in the new stack.
  5. To reorder diffs non-interactively, run glab stack reorder <branch>... with the branches in the desired order. Run glab stack list first to get the branch names.
    • List every branch in the stack exactly once. A missing, unknown, or duplicate branch is an error.
    • The first branch becomes the diff closest to the base branch; the last becomes the newest.
    • Commit or stash tracked changes first. reorder refuses to run with uncommitted changes.
    • reorder rebases branches locally only. Run glab stack sync afterwards to force-push them.
  6. To infer diffs from a commit range non-interactively, run glab stack infer --all <revision-range>. If no stack is active, also pass --name <stack-name>, or infer fails without a TTY.

Stack structure

Plan your diff boundaries before writing code. Earlier diffs (closer to main) are the foundation; later diffs depend on them. If code in one diff depends on code in another, the dependency must be in the same diff or an earlier one.

save vs amend:

  • glab stack save — creates a new diff (new commit, new branch). Use when adding a new logical concern on top of what exists.
  • glab stack amend — modifies the diff you have checked out. Use when addressing review feedback or fixing a mistake in that diff.

Important: If you navigate to an earlier diff and run save instead of amend, the CLI will warn you but still proceed — appending the new diff to the end of the stack, not inserting it at the current position. Always use amend when you've navigated to a specific diff to address feedback. Only use save from the last diff in the stack.

For precise control over which files go into a diff, stage with git add <files> first, then glab stack save -m "...". For convenience, -a stages all tracked/modified files, and passing . stages everything including untracked files.

Quick reference

TaskCommand
Create a new stackglab stack create <stack-name>
Save staged changes as a new diffglab stack save -m "description"
Stage all tracked files and saveglab stack save -a -m "description"
Stage all files (incl. untracked) and saveglab stack save . -m "description"
Amend the diff you have checked outglab stack amend -m "description"
Amend with all tracked files stagedglab stack amend -a -m "description"
Push branches and create/update MRsglab stack sync
Sync and set reviewer/assignee/labelglab stack sync --reviewer <user> --assignee <user> --label <label>
Rebase stack onto latest base branchglab stack sync --update-base
Reorder diffs non-interactivelyglab stack reorder <branch>...
Continue a reorder after resolving a conflictglab stack reorder --continue
Abort a reorder and restore the original orderglab stack reorder --abort
Add diffs from commit range without editorglab stack infer --all <revision-range>
Infer into a new stack without editorglab stack infer --all --name <stack-name> <revision-range>
List all diffs in the stackglab stack list
Go to the oldest diffglab stack first
Go to the newest diffglab stack last
Step toward mainglab stack prev
Step away from mainglab stack next
Switch to a different stackglab stack switch <stack-name>

Core workflow

bash
# 1. Create a stack for a feature
glab stack create add-authentication

# 2. Build the first diff (data model)
git add app/models/user.rb db/migrate/001_create_users.rb
glab stack save -m "Add user model and migration"

# 3. Build the second diff (API) — depends on the model above
git add app/controllers/sessions_controller.rb
glab stack save -m "Add session controller"

# 4. Build the third diff (UI) — depends on the API above
glab stack save . -m "Add login view and assets"

# 5. Push all branches and open MRs on GitLab
glab stack sync

After sync, each diff has its own MR: !1 targets main, !2 targets the !1 branch, and so on. Reviewers see only the changes in their diff.

sync fetches from origin first, then pushes each branch and creates or updates MRs. If a branch is detected as behind its remote (e.g., a reviewer applied a suggestion through the GitLab web UI), sync will pull those changes before pushing. You don't need to manually pull stack branches before syncing in the common case.

Setting reviewers, assignees, and labels: Pass --reviewer, --assignee, and --label flags to sync to set these on newly created MRs. If no --assignee is specified, new MRs are auto-assigned to the current authenticated user. These flags only affect MR creation — they do not update MRs that already exist. To update an existing MR, use glab mr update <mr-number>.

Merged and closed MRs: During sync, any MR that has been merged has its ref automatically removed from the stack. Closed MRs are flagged in output but not removed — the ref stays in the stack.

Rebasing onto an updated base branch: If the base branch (e.g., main) has moved forward, run glab stack sync --update-base to rebase the entire stack onto the latest base.

Merge diffs in order, first to last. Always merge the first diff (oldest, closest to main) before merging the ones after it. When the first diff merges, sync automatically retargets the next MR onto main. If a middle diff is merged out of order, the earlier MR will show a combined diff that doesn't belong to it — there's no clean automated recovery.

Responding to review feedback

bash
# Navigate to the diff that needs changes
glab stack list          # see all diffs and where you are
glab stack first         # or: prev, next, last
# (make edits)
glab stack amend -a -m "Address review: improve null handling"

# Sync rebases all downstream diffs automatically
glab stack sync

Handling sync conflicts

If sync hits a conflict during rebase:

bash
# Resolve conflict markers in affected files, then:
git add <resolved-files>
git rebase --continue

# Re-run sync to push the resolved stack
glab stack sync

Handling reorder conflicts

If reorder hits a conflict while rebasing a branch:

bash
# Resolve conflict markers in affected files, then:
git add <resolved-files>
git rebase --continue

# Resume the reorder for the remaining branches
glab stack reorder --continue

# Or restore the original branch order instead
glab stack reorder --abort

After the reorder completes, run glab stack sync to push the rebased branches.

1---
2name: glab-stack
3description: Manage stacked diffs and merge requests with the GitLab CLI. Use when the user wants to create, save, amend, sync, navigate, reorder, or infer from commits a stack of dependent merge requests. Triggers on tasks involving stacked diffs, stacked MRs, dependent merge requests, or incremental code review workflows using `glab stack`.
4---
6# glab stack
8`glab stack` is a feature of the [GitLab CLI](https://gitlab.com/gitlab-org/cli) for managing **stacked diffs**: small, dependent changes that build on each other to deliver a larger feature. Each diff in the stack is a separate branch with its own MR. Reviewers see only the changes in their diff; you keep building while earlier changes are in review.
10> **Status:** Experiment, released in GitLab CLI v1.42.0. The interface may change.
12## How glab stack works
14`glab stack` uses a **save-centric model**: `glab stack save` bundles staging, committing, and branch creation into a single step. There are no separate Git operations for creating stack branches — the CLI manages branch creation automatically. Stack metadata lives in `.git/stacked/` in the repo.
16Each diff gets its own branch named `{branch_prefix}-{stack-title}-{8-char-hex}`. The branch prefix defaults to the current user's username (from `os/user.Current`), falling back to `glab-stack` if unavailable; it can also be set with `glab config set branch_prefix <value>`. The hash is generated at save time from the message, title, author, and timestamp — branch names are not sequential or predictable in advance. Use `glab stack list` to see the current branch names for each diff.
18```text
19main (default branch)
20 └── karmstrong-add-auth-5b337685 → MR !1 (targets main) ← first diff (oldest)
21 └── karmstrong-add-auth-74f87791 → MR !2 (targets karmstrong-add-auth-5b337685)
22 └── karmstrong-add-auth-c3a91b02 → MR !3 (targets karmstrong-add-auth-74f87791) ← last diff (newest)
23```
25Stack names are sanitized on creation: spaces and special characters are replaced with dashes. The name `"add auth feature"` becomes `add-auth-feature`. Always use the sanitized form with `glab stack switch`.
27You can have multiple named stacks per repo and switch between them with `glab stack switch`.
29## When to use stacks
31Stacks work well when:
33- A feature is large enough that a single MR would be hard to review
34- Changes have a clear dependency order — data layer feeds the API layer feeds the UI
35- You want to unblock reviewers on completed diffs while you keep building
36- Feedback on one diff shouldn't block progress on the diffs after it
38Each diff should represent a discrete, logical concern that can be reviewed independently. A reviewer reading the MRs in sequence should understand the progression as a cohesive story.
40## Agent rules
42**These commands launch interactive TUIs or prompt for input — they hang or fail without a TTY:**
44- ❌ `glab stack move` — fuzzy-finder for selecting a diff; agents cannot interact with it
45- ❌ `glab stack reorder` without arguments — opens a text editor to reorder diffs, or fails without a TTY; pass branch names in order instead (`glab stack reorder <branch>...`)
46- ❌ `glab stack infer` without `--all` — opens a text editor to select commits, or fails without a TTY; pass `--all` instead (`glab stack infer --all <revision-range>`)
47- ❌ `glab stack save` without `-m` — prompts interactively for a commit message if none is provided
48- ❌ `glab stack amend` without `-m` — prompts interactively for a description if none is provided
49- ❌ `glab stack create` without a name argument — may prompt
51**Always do the following:**
531. **Always pass `-m` to `save` and `amend`.** This is the most common footgun — without it, the CLI prompts interactively and hangs.
542. **Use `glab stack list` to inspect the stack, not `glab stack move`.** `list` is non-interactive; `move` is not usable by agents.
553. **Navigate with `first`, `last`, `prev`, `next`.** These are all non-interactive. Do not use `move` for navigation.
564. **Pass an explicit name to `glab stack switch`.** Stack names are the directory names under `.git/stacked/`. Note: `switch` only changes the active stack in config — it does not check out any branch. After switching, use `glab stack last` (or `first`, `next`, etc.) to move to a diff in the new stack.
575. **To reorder diffs non-interactively**, run `glab stack reorder <branch>...` with the branches in the desired order. Run `glab stack list` first to get the branch names.
58 - List every branch in the stack exactly once. A missing, unknown, or duplicate branch is an error.
59 - The first branch becomes the diff closest to the base branch; the last becomes the newest.
60 - Commit or stash tracked changes first. `reorder` refuses to run with uncommitted changes.
61 - `reorder` rebases branches locally only. Run `glab stack sync` afterwards to force-push them.
626. **To infer diffs from a commit range non-interactively**, run `glab stack infer --all <revision-range>`. If no stack is active, also pass `--name <stack-name>`, or `infer` fails without a TTY.
64## Stack structure
66Plan your diff boundaries before writing code. Earlier diffs (closer to main) are the foundation; later diffs depend on them. If code in one diff depends on code in another, the dependency must be in the same diff or an earlier one.
68**`save` vs `amend`:**
70- `glab stack save` — creates a **new** diff (new commit, new branch). Use when adding a new logical concern on top of what exists.
71- `glab stack amend` — modifies the diff you have **checked out**. Use when addressing review feedback or fixing a mistake in that diff.
73**Important:** If you navigate to an earlier diff and run `save` instead of `amend`, the CLI will warn you but still proceed — appending the new diff to the **end** of the stack, not inserting it at the current position. Always use `amend` when you've navigated to a specific diff to address feedback. Only use `save` from the last diff in the stack.
75For precise control over which files go into a diff, stage with `git add <files>` first, then `glab stack save -m "..."`. For convenience, `-a` stages all tracked/modified files, and passing `.` stages everything including untracked files.
77## Quick reference
79| Task | Command |
80| ---- | ------- |
81| Create a new stack | `glab stack create <stack-name>` |
82| Save staged changes as a new diff | `glab stack save -m "description"` |
83| Stage all tracked files and save | `glab stack save -a -m "description"` |
84| Stage all files (incl. untracked) and save | `glab stack save . -m "description"` |
85| Amend the diff you have checked out | `glab stack amend -m "description"` |
86| Amend with all tracked files staged | `glab stack amend -a -m "description"` |
87| Push branches and create/update MRs | `glab stack sync` |
88| Sync and set reviewer/assignee/label | `glab stack sync --reviewer <user> --assignee <user> --label <label>` |
89| Rebase stack onto latest base branch | `glab stack sync --update-base` |
90| Reorder diffs non-interactively | `glab stack reorder <branch>...` |
91| Continue a reorder after resolving a conflict | `glab stack reorder --continue` |
92| Abort a reorder and restore the original order | `glab stack reorder --abort` |
93| Add diffs from commit range without editor | `glab stack infer --all <revision-range>` |
94| Infer into a new stack without editor | `glab stack infer --all --name <stack-name> <revision-range>` |
95| List all diffs in the stack | `glab stack list` |
96| Go to the oldest diff | `glab stack first` |
97| Go to the newest diff | `glab stack last` |
98| Step toward main | `glab stack prev` |
99| Step away from main | `glab stack next` |
100| Switch to a different stack | `glab stack switch <stack-name>` |
102## Core workflow
104```bash
105# 1. Create a stack for a feature
106glab stack create add-authentication
108# 2. Build the first diff (data model)
109git add app/models/user.rb db/migrate/001_create_users.rb
110glab stack save -m "Add user model and migration"
112# 3. Build the second diff (API) — depends on the model above
113git add app/controllers/sessions_controller.rb
114glab stack save -m "Add session controller"
116# 4. Build the third diff (UI) — depends on the API above
117glab stack save . -m "Add login view and assets"
119# 5. Push all branches and open MRs on GitLab
120glab stack sync
121```
123After `sync`, each diff has its own MR: !1 targets `main`, !2 targets the !1 branch, and so on. Reviewers see only the changes in their diff.
125**`sync` fetches from origin first**, then pushes each branch and creates or updates MRs. If a branch is detected as behind its remote (e.g., a reviewer applied a suggestion through the GitLab web UI), `sync` will pull those changes before pushing. You don't need to manually pull stack branches before syncing in the common case.
127**Setting reviewers, assignees, and labels:** Pass `--reviewer`, `--assignee`, and `--label` flags to `sync` to set these on newly created MRs. If no `--assignee` is specified, new MRs are auto-assigned to the current authenticated user. These flags only affect MR creation — they do not update MRs that already exist. To update an existing MR, use `glab mr update <mr-number>`.
129**Merged and closed MRs:** During sync, any MR that has been merged has its ref automatically removed from the stack. Closed MRs are flagged in output but not removed — the ref stays in the stack.
131**Rebasing onto an updated base branch:** If the base branch (e.g., `main`) has moved forward, run `glab stack sync --update-base` to rebase the entire stack onto the latest base.
133**Merge diffs in order, first to last.** Always merge the first diff (oldest, closest to main) before merging the ones after it. When the first diff merges, `sync` automatically retargets the next MR onto main. If a middle diff is merged out of order, the earlier MR will show a combined diff that doesn't belong to it — there's no clean automated recovery.
135### Responding to review feedback
137```bash
138# Navigate to the diff that needs changes
139glab stack list # see all diffs and where you are
140glab stack first # or: prev, next, last
141# (make edits)
142glab stack amend -a -m "Address review: improve null handling"
144# Sync rebases all downstream diffs automatically
145glab stack sync
146```
148### Handling sync conflicts
150If `sync` hits a conflict during rebase:
152```bash
153# Resolve conflict markers in affected files, then:
154git add <resolved-files>
155git rebase --continue
157# Re-run sync to push the resolved stack
158glab stack sync
159```
161### Handling reorder conflicts
163If `reorder` hits a conflict while rebasing a branch:
165```bash
166# Resolve conflict markers in affected files, then:
167git add <resolved-files>
168git rebase --continue
170# Resume the reorder for the remaining branches
171glab stack reorder --continue
173# Or restore the original branch order instead
174glab stack reorder --abort
175```
177After the reorder completes, run `glab stack sync` to push the rebased branches.
Diagnostics10 git calls · 204 ms
CallStatusSizeTime0204 ms
discover200185 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=185
git.server.agent=git/2.56.g1891de4-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=185
git.pkt.payload.max=35
ls-refs20058 KiB · hit3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=59849
git.response.cache=HIT
git.response.duration_ms=3
git.protocol.version=2
git.pkt.frames=731
git.pkt.data=730
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=59849
git.pkt.payload.max=143
git.ls_refs.count=730
git.ls_refs.head=refs/heads/main
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4273
git.pkt.payload.max=4173
git.sideband.band1.bytes=4173
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=11
git.pack.bytes=4173
git.fetch.wide.objects=11
git.fetch.wide.extra_bytes=3930
git.fetch.wide.blobs=0
fetchtree:0 · deepen 1020032 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=22
git.pkt.data=20
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=32926
git.pkt.payload.max=32046
git.sideband.band1.bytes=32046
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=80
git.pack.bytes=32046
git.pack.ofs_delta=36
git.pack.ref_delta=0
git.pack.chain.max=2
git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91
git.pack.full=44
Open pack map
fetchtree:02001.8 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=1857
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=dce174ff8c632a19d17eea99c8a9b7c37fb2b592
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=1857
git.pkt.payload.max=1830
git.sideband.band1.bytes=1830
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1830
git.pack.trailer=fb03183b7909876778f740d196d7516811003517
Open pack map
fetchtree:0200370 B · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=370
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=290ae7a62f76e23cbbd60697570f19b90ddcece6
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=370
git.pkt.payload.max=343
git.sideband.band1.bytes=343
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=343
git.pack.trailer=0795a26d2b25022c69da2ef2e68cfb92a77ef4bb
Open pack map
fetchtree:0200172 B · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=172
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=1d776c45e9ce17714f94b096cf4965ac6cec85d5
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=172
git.pkt.payload.max=145
git.sideband.band1.bytes=145
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=145
git.pack.trailer=4366d9320a915cc228b00c299374927ba2a6e519
Open pack map
fetchtree:0200132 B · hit5 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=5
git.response.bytes=132
git.response.cache=HIT
git.response.duration_ms=5
git.fetch.filter=tree:0
git.fetch.wants=56b988ad01c82fb902f0db541844708590763fc3
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=132
git.pkt.payload.max=105
git.sideband.band1.bytes=105
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=105
git.pack.trailer=127c983927de543aaade2a59ae5622d6a8775441
Open pack map
fetchtree:0200106 B · hit4 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=4
git.response.bytes=106
git.response.cache=HIT
git.response.duration_ms=4
git.fetch.filter=tree:0
git.fetch.wants=c7e272434f5f98d316fcfd3d9918b3837f87471f
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=106
git.pkt.payload.max=79
git.sideband.band1.bytes=79
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=79
git.pack.trailer=d51cb78b2283478fdf678114a60c07ef97292fe9
Open pack map
fetch2004.2 KiB184 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=183
git.response.bytes=4262
git.response.cache=MISS
git.response.duration_ms=184
git.fetch.wants=47986d431920a881c9a06839c83ce5ab6e4b5a75
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=4262
git.pkt.payload.max=4235
git.sideband.band1.bytes=4235
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://gitlab.com/gitlab-org/cli
Ref
refs/heads/main
Commit
0dd7574dce9e385c5c30540e6c15657adc6bdce9
cf-ray
a5e318caddbc3e6e
Request
83db88a8…
Protocol
v2 · sha1
Agent
git/2.56.g1891de4-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format