# Bad: "the push fails"
# Good:
git push origin GT-241

# Without the global or system configuration
GIT_CONFIG_GLOBAL=/dev/null GIT_CONFIG_SYSTEM=/dev/null git status

# Without hooks (lesson 06-01)
git -c core.hooksPath=/dev/null commit -m "test"
git commit --no-verify -m "test"

# Without aliases or repository configuration
git -c include.path= <command>

# In a freshly cloned repository, in /tmp
git clone <url> /tmp/clean-test && cd /tmp/clean-test

GIT_TRACE=/tmp/trace.log git status

GIT_TRACE=1 git status

10:14:22.104 git.c:463               trace: built-in: git status
10:14:22.108 run-command.c:657       trace: run_command: 'gpg' '--status-fd=2' '-bsau' 'ana.ferrer@example.com'

GIT_TRACE=1 git lg

10:15:03.221 git.c:750               trace: alias expansion: lg => 'log' '--graph' '--abbrev-commit' '--date=relative'
10:15:03.222 git.c:463               trace: built-in: git log --graph --abbrev-commit --date=relative

GIT_TRACE=1 git commit -m "test" 2>&1 | grep -i hook

ls -l .git/hooks/pre-commit
git config --get core.hooksPath

GIT_TRACE_SETUP=1 git status

10:16:41.003 trace.c:318  setup: git_dir: /home/ana/projects/task-manager/.git
10:16:41.003 trace.c:319  setup: git_common_dir: /home/ana/projects/task-manager/.git
10:16:41.003 trace.c:320  setup: worktree: /home/ana/projects/task-manager
10:16:41.003 trace.c:321  setup: cwd: /home/ana/projects/task-manager/src
10:16:41.003 trace.c:322  setup: prefix: src/

GIT_SSH_COMMAND="ssh -v" git fetch 2>&1 | head -40

debug1: Reading configuration data /home/ana/.ssh/config
debug1: /home/ana/.ssh/config line 4: Applying options for git.example.com
debug1: Connecting to git.example.com [192.0.2.10] port 22.
debug1: Offering public key: /home/ana/.ssh/id_rsa RSA SHA256:xxxx agent
debug1: Authentications that can continue: publickey
debug1: Offering public key: /home/ana/.ssh/id_ed25519 ED25519 SHA256:yyyy agent
debug1: Server accepts key: /home/ana/.ssh/id_ed25519 ED25519 SHA256:yyyy agent
debug1: Authentication succeeded (publickey).

Host git.example.com
    User git
    IdentityFile ~/.ssh/id_ed25519_example
    IdentitiesOnly yes

GIT_CURL_VERBOSE=1 git fetch 2>&1 | head -40

* Connected to git.example.com (192.0.2.10) port 443
> GET /team/task-manager.git/info/refs?service=git-upload-pack HTTP/2
> User-Agent: git/2.45.0
< HTTP/2 401
< www-authenticate: Basic realm="Git"
* Issue another request to this URL
> Authorization: Basic YW5hOnh4eA==
< HTTP/2 200

git config --get credential.helper
git credential-cache exit          # empty the cached credentials
printf 'protocol=https\nhost=git.example.com\n\n' | git credential fill

GIT_TRACE_PACKET=1 git fetch 2>&1 | head -30

packet:        git< version 2
packet:        git< agent=git/2.45.0
packet:        git< ls-refs=unborn
packet:        git< fetch=shallow wait-for-done
packet:        git< object-format=sha1
packet:        git> command=ls-refs
packet:        git> peel
packet:        git> ref-prefix refs/heads/
packet:        git< b52c9d1e4a7f3c8b6d2e9a5f1c7b3d8e4a6f2c9b refs/heads/main
packet:        git< 7d3a8f4a2c6e9b1d5f3a8c6e2b9d4f7a1c5e8b3d refs/heads/GT-241

git config --get protocol.version      # should be 2 in a modern Git
git -c protocol.version=2 fetch

# In the current session
export GIT_TRACE=1
export GIT_TRACE_SETUP=1
# ...reproduce the problem...
unset GIT_TRACE GIT_TRACE_SETUP

#!/usr/bin/env bash
# capture-trace.sh <git command...>
LOG=/tmp/git-trace-$(date +%s).log
GIT_TRACE="$LOG" \
GIT_TRACE_SETUP="$LOG" \
GIT_TRACE_PERFORMANCE="$LOG" \
GIT_TRACE_PACKET="$LOG" \
  "$@"
echo "Trace in: $LOG"
echo "REVIEW the file before sharing it: it may contain credentials."

git config --list --show-origin --show-scope

system  /etc/gitconfig          core.autocrlf=false
global  /home/ana/.gitconfig    user.name=Ana Ferrer
global  /home/ana/.gitconfig    user.email=ana.ferrer@example.com
global  /home/ana/.gitconfig    pull.rebase=true
local   .git/config             remote.origin.url=git.example.com:team/task-manager.git
local   .git/config             user.email=ana@personal.example
local   .git/config             core.autocrlf=input

# Which value wins
git config --get user.email

# ALL the defined values, in order of precedence (the last one wins)
git config --get-all user.email

# With their origin
git config --get-all --show-origin user.email

# Everything beginning with a prefix
git config --get-regexp '^remote\.'
git config --get-regexp '^alias\.'
git config --get-regexp '^advice\.'

# Try a value without changing anything, just for this command
git -c core.autocrlf=false status
git -c diff.noprefix=false diff

# See what happens WITHOUT the user configuration
GIT_CONFIG_GLOBAL=/dev/null GIT_CONFIG_SYSTEM=/dev/null git status

# ~/.gitconfig
[includeIf "gitdir:~/projects/work/"]
    path = ~/.gitconfig-work

[includeIf "gitdir:~/projects/personal/"]
    path = ~/.gitconfig-personal

git check-ignore -v data/dump.sql

.gitignore:12:*.sql	data/dump.sql

# Several files at once
git check-ignore -v app.js data/dump.sql node_modules/x/y.js

# Everything being ignored in the project
git status --ignored --short

# And the baffling case: why is it NOT ignored?
git check-ignore -v --no-index local-config.json
echo $?

git ls-files --error-unmatch local-config.json

local-config.json

git rm --cached local-config.json
git commit -m "chore: stop version-controlling the local configuration"

git check-ignore -v screenshots/screen.png

.gitignore:8:screenshots/	screenshots/screen.png

screenshots/
!screenshots/important.png     # DOES NOT work: Git does not go into screenshots/

screenshots/*
!screenshots/important.png     # DOES work

git check-attr -a styles.css

styles.css: text: set
styles.css: eol: lf
styles.css: diff: css

# One particular attribute
git check-attr eol text diff -- styles.css index.html app.js

# Where each rule comes from
git check-attr -a --source=HEAD styles.css

# For all tracked files
git ls-files | git check-attr --stdin -a | grep -v unspecified

# What is tracked
git ls-files

# With metadata: mode, hash and stage
git ls-files --stage app.js

100644 6f2b9d4a8c1e5f3b7d9a2c6e4f8b1d3a5c7e9f2b 0	app.js

git ls-files --stage | awk '$3 != 0'

100644 4f8a2e6... 1	app.js
100644 b52c9d1... 2	app.js
100644 7d3a8f4... 3	app.js

# Why does Git say this script has changed if all I did was set permissions?
git ls-files --stage build.sh

100644 8a1f6c3... 0	build.sh

ls -l build.sh

-rwxr-xr-x 1 ana ana 412 Jul 28 10:02 build.sh

git update-index --chmod=+x build.sh

git ls-files --eol app.js styles.css index.html

i/lf    w/crlf  attr/text=auto  	app.js
i/lf    w/lf    attr/            	styles.css
i/crlf  w/crlf  attr/-text       	index.html

git ls-files --others                        # untracked
git ls-files --others --exclude-standard      # untracked and not ignored
git ls-files --ignored --exclude-standard     # ignored
git ls-files --deleted                        # deleted from disk but still in the index
git ls-files --modified                       # modified
git ls-files --unmerged                       # in conflict

git rev-parse HEAD
git rev-parse main
git rev-parse HEAD~3
git rev-parse GT-241@{2}
git rev-parse v1.5.0^{commit}      # an annotated tag points at a tag object; this gives the commit

git rev-parse --show-toplevel        # the project root
git rev-parse --git-dir              # where the .git is
git rev-parse --git-common-dir       # the shared .git (worktrees, 06-06)
git rev-parse --abbrev-ref HEAD      # the current branch's name
git rev-parse --is-inside-work-tree  # true/false
git rev-parse --is-bare-repository   # true/false
git rev-parse --symbolic-full-name @{u}   # the full upstream

/home/ana/projects/task-manager
/home/ana/projects/task-manager/.git
GT-241
true
refs/remotes/origin/GT-241

# How many commits there are
git rev-list --count HEAD

# How many ahead and behind (lesson 09-03)
git rev-list --left-right --count main...origin/main

# Commits that touched a file
git rev-list HEAD -- app.js | head

# All reachable objects (lesson 08-06)
git rev-list --objects --all | wc -l

# The root commits (is there more than one? → unrelated histories)
git rev-list --max-parents=0 HEAD

# Only merges, or only what are not merges
git rev-list --merges HEAD | head
git rev-list --no-merges HEAD | head

# The type and size of an object
echo 4f8a2e6 | git cat-file --batch-check

4f8a2e6c9b1d5e3a7f2c8b6d9e4a1f5c3b7d2e9a commit 241

# Check whether it exists (without dumping the content)
git cat-file -e 4f8a2e6 && echo "it exists" || echo "it does not exist"

# A report of all the objects by type
git rev-list --objects --all \
  | git cat-file --batch-check='%(objecttype)' \
  | sort | uniq -c

  18432 blob
   3204 commit
  21908 tree
     47 tag

git verify-pack -v .git/objects/pack/pack-*.idx | head -5

b52c9d1e4a7f3c8b6d2e9a5f1c7b3d8e4a6f2c9b commit 241 168 12
7d3a8f4a2c6e9b1d5f3a8c6e2b9d4f7a1c5e8b3d tree   118  94 180
4f8a2e6c9b1d5e3a7f2c8b6d9e4a1f5c3b7d2e9a blob  8241 2104 274
6f2b9d4a8c1e5f3b7d9a2c6e4f8b1d3a5c7e9f2b blob   412  87 2378 1 4f8a2e6c9b1d5e3a

# Statistics for the delta chains
git verify-pack -v .git/objects/pack/pack-*.idx | tail -20

git for-each-ref --sort=-committerdate --format='%(refname:short)  %(objectname:short)  %(committerdate:relative)  %(authorname)' refs/heads

GT-241     9c4e7b2  2 hours ago    Ana Ferrer
GT-238     7d3a8f4  3 days ago     Bruno Salas
main       b52c9d1  4 days ago     Carla Vidal

# Branches with no upstream: they exist only on this machine (lesson 09-05)
git for-each-ref --format='%(refname:short) %(upstream)' refs/heads | awk '$2==""{print $1}'

# References pointing at non-existent objects (lesson 09-05)
git for-each-ref --format='%(refname) %(objectname)' | while read -r r s; do
  git cat-file -e "$s" 2>/dev/null || echo "BROKEN: $r"
done

git ls-remote origin
git ls-remote origin 'refs/heads/GT-*'
git ls-remote --heads origin main

b52c9d1e4a7f3c8b6d2e9a5f1c7b3d8e4a6f2c9b	refs/heads/main

[ "$(git ls-remote origin main | cut -f1)" = "$(git rev-parse origin/main)" ] \
  && echo "up to date" || echo "my copy of origin/main is out of date"

# What changed between two versions, by file
git diff --stat v1.4.0 v1.5.0

 app.js         |  84 ++++++++++++++++-----
 styles.css     |  12 ++--
 index.html     |   6 +-
 README.md      |  31 ++++++++
 4 files changed, 108 insertions(+), 25 deletions(-)

# Only the names, to see the scope at a glance
git diff --name-only v1.4.0 v1.5.0

# With the type of change: Added, Modified, Deleted, Renamed
git diff --name-status v1.4.0 v1.5.0

# A summary of renames and mode changes
git diff --summary v1.4.0 v1.5.0

# Compare only a branch's effect (lesson 07-02)
git diff --stat main...GT-241

# Commits that touched one particular function
git log -L :calculatePending:app.js

# Commits that added or removed a string (pickaxe, lesson 02-06)
git log -S "localStorage" --oneline

# Commits whose diff matches a regular expression
git log -G "taskmanager\.tasks\.v[0-9]" --oneline

# Who and when, in a date range
git log --since="2026-07-01" --until="2026-07-31" --format='%h %an %ad %s' --date=short

# Only what came in through the first-parent line (lesson 08-02)
git log --first-parent --oneline main

cat > /tmp/counter-test.sh <<'EOF'
#!/usr/bin/env bash
# Exits 0 if the counter is correct, 1 if not.
node -e '
  const fs = require("fs");
  const src = fs.readFileSync("app.js", "utf8");
  const ctx = { localStorage: { getItem: () => null, setItem: () => {} }, document: null };
  // ... minimal start-up of the application ...
  const tasks = [
    { text: "a", completed: false, hidden: false },
    { text: "b", completed: true,  hidden: false },
    { text: "c", completed: false, hidden: true  }
  ];
  const expected = 2;
  const actual = calculatePending(tasks);
  process.exit(actual === expected ? 0 : 1);
' 2>/dev/null
EOF
chmod +x /tmp/counter-test.sh

git tag --sort=-creatordate | head -3
git diff --stat v1.4.0 v1.5.0 -- app.js

v1.5.0
v1.4.0
v1.3.0

 app.js | 84 ++++++++++++++++-----
 1 file changed, 62 insertions(+), 22 deletions(-)

git rev-list --count v1.4.0..v1.5.0

34

git bisect start
git bisect bad v1.5.0
git bisect good v1.4.0
git bisect run /tmp/counter-test.sh

Bisecting: 16 revisions left to test after this (roughly 4 steps)
[7d3a8f4a2c6e9b1d5f3a8c6e2b9d4f7a1c5e8b3d] GT-238 extract the element creation
running  /tmp/counter-test.sh
Bisecting: 8 revisions left to test after this (roughly 3 steps)
...
4f8a2e6c9b1d5e3a7f2c8b6d9e4a1f5c3b7d2e9a is the first bad commit
commit 4f8a2e6c9b1d5e3a7f2c8b6d9e4a1f5c3b7d2e9a
Author: Bruno Salas <bruno.salas@example.com>
Date:   Wed Jul 15 11:23:04 2026 +0200

    GT-231 add the hidden tasks filter

 app.js | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

git bisect reset

git show 4f8a2e6

 function calculatePending(tasks) {
-  return tasks.filter(t => !t.completed).length;
+  return tasks.filter(t => !t.completed || t.hidden).length;
 }

git blame -L 12,20 app.js

4f8a2e6c (Bruno Salas  2026-07-15 11:23:04 +0200 12) function calculatePending(tasks) {
4f8a2e6c (Bruno Salas  2026-07-15 11:23:04 +0200 13)   return tasks.filter(t => !t.completed || t.hidden).length;
4f8a2e6c (Bruno Salas  2026-07-15 11:23:04 +0200 14) }
b52c9d1e (Ana Ferrer   2026-06-28 09:14:22 +0200 15)
b52c9d1e (Ana Ferrer   2026-06-28 09:14:22 +0200 16) function renderTasks() {

# The complete history of that function, even if it has moved
git log -L :calculatePending:app.js --format='%h %an %ad %s' --date=short

commit 4f8a2e6 Bruno Salas 2026-07-15 GT-231 add the hidden tasks filter
commit 8a1f6c3 Ana Ferrer  2026-05-02 GT-198 extract the calculation into its own function
commit 2f8c6e1 Ana Ferrer  2026-04-11 GT-142 show the pending counter

# The culprit commit's complete message: the "why"
git log -1 --format=%B 4f8a2e6

GT-231 add the hidden tasks filter

Archived tasks no longer appear in the list. The `hidden` flag is
added and filtered on in renderTasks().

The counter must carry on including them because the GT-231
specification says that "pending" counts every task that is not
completed, whether visible or not.

# Who else depends on this? (pickaxe, lesson 02-06)
git log -S "calculatePending" --oneline
git grep -n "calculatePending" -- '*.js'

#!/usr/bin/env bash
# git-diagnostics.sh — a complete snapshot of the repository's real state
set -u
echo "=== ENVIRONMENT ==="
git --version
git rev-parse --show-toplevel
git rev-parse --git-dir
echo "branch: $(git rev-parse --abbrev-ref HEAD)"
echo "upstream: $(git rev-parse --symbolic-full-name '@{u}' 2>/dev/null || echo 'none')"

echo; echo "=== STATE ==="
git status -sb | head -20

echo; echo "=== DIVERGENCE ==="
git rev-list --left-right --count HEAD...@{u} 2>/dev/null || echo "no upstream"

echo; echo "=== KEY CONFIGURATION ==="
git config --list --show-scope 2>/dev/null \
  | grep -E '(user\.|core\.(autocrlf|eol|hooksPath|excludesFile|fsmonitor)|pull\.|push\.|merge\.|diff\.)'

echo; echo "=== ACTIVE HOOKS ==="
HOOKS_PATH=$(git config --get core.hooksPath || echo "$(git rev-parse --git-dir)/hooks")
find "$HOOKS_PATH" -maxdepth 1 -type f -perm -u+x ! -name '*.sample' 2>/dev/null

echo; echo "=== REFERENCES ==="
echo "local branches: $(git branch | wc -l) | remote: $(git branch -r | wc -l) | tags: $(git tag | wc -l)"
echo "unpublished: $(git for-each-ref --format='%(refname:short) %(upstream)' refs/heads | awk '$2==""{print $1}' | tr '\n' ' ')"

echo; echo "=== INTEGRITY ==="
git fsck --connectivity-only --no-progress 2>&1 | grep -vE '^(dangling|notice|Checking)' || echo "no errors"

echo; echo "=== LATEST MOVEMENTS ==="
git reflog --date=relative -8

rm -rf /tmp/p9-06 && mkdir /tmp/p9-06 && cd /tmp/p9-06 && git init -q -b main
git config user.name "Carla Vidal"; git config user.email "carla.vidal@example.com"
printf 'console.log(1);\n' > app.js
printf 'body { margin: 0; }\n' > styles.css
printf '<h1>Manager</h1>\n' > index.html
git add . && git commit -q -m "chore: initial structure"

# 2. The .gitattributes
printf '*.css text eol=crlf\n' > .gitattributes
git add .gitattributes && git commit -q -m "chore: force CRLF in the CSS files"

# 3. The symptom
git status --short

(no output)

rm styles.css && git checkout -- styles.css
git status --short
file styles.css

 M styles.css

styles.css: ASCII text, with CRLF line terminators

git ls-files --eol
git check-attr -a styles.css

i/lf    w/crlf  attr/text eol=crlf 	styles.css
i/lf    w/lf    attr/              	app.js
i/lf    w/lf    attr/              	index.html
i/lf    w/lf    attr/              	.gitattributes

styles.css: text: set
styles.css: eol: crlf

# 4. The explanation
git diff --stat styles.css

 styles.css | 2 +-

# 5. The solution
git add --renormalize .
git status --short
git commit -q -m "chore: renormalise the line endings"
git ls-files --eol styles.css

M  styles.css

i/lf    w/crlf  attr/text eol=crlf 	styles.css

git status --short

(no output)

# 6. With -diff
printf '*.css text eol=crlf\nindex.html -diff\n' > .gitattributes
git add .gitattributes && git commit -q -m "chore: index.html without diff"
printf '<h1>Task manager</h1>\n' > index.html
git diff index.html
git check-attr diff -- index.html

diff --git a/index.html b/index.html
index 8a1f6c3..4f8a2e6 100644
Binary files a/index.html and b/index.html differ

index.html: diff: unset

rm -rf /tmp/p9-06b && mkdir /tmp/p9-06b && cd /tmp/p9-06b && git init -q -b main
git config --global user.email "ana.ferrer@example.com" 2>/dev/null
git config user.name "Ana Ferrer"
git config user.email "ana@personal.example"      # local, different

# 2. Which one wins
git config --list --show-origin --show-scope | grep user.email

global	/home/ana/.gitconfig	user.email=ana.ferrer@example.com
local	.git/config	user.email=ana@personal.example

git config --get user.email
echo "x" > f.txt && git add . && git commit -q -m "test"
git log -1 --format='%ae'

ana@personal.example

ana@personal.example

# 3. The three layers of ignores
printf '*.log\n' > .gitignore
printf '!important.log\n' > .git/info/exclude
printf 'temp*\n' > /tmp/global-gitignore
git config core.excludesFile /tmp/global-gitignore

touch output.log important.log temp-1.txt normal.txt

for f in output.log important.log temp-1.txt normal.txt; do
  printf '%-18s ' "$f"
  git check-ignore -v "$f" || echo "(not ignored)"
done

output.log         .gitignore:1:*.log	output.log
important.log      .git/info/exclude:1:!important.log	important.log
temp-1.txt         /tmp/global-gitignore:1:temp*	temp-1.txt
normal.txt         (not ignored)

git status --short | grep important

?? important.log

# 4. The hook that does not run
cat > .git/hooks/pre-commit <<'EOF'
#!/usr/bin/env bash
echo "HOOK EXECUTED"
EOF
# without chmod +x
echo "y" >> f.txt
GIT_TRACE=1 git commit -q -am "hook test" 2>&1 | grep -ci "pre-commit"
git log -1 --format=%s

0

hook test

ls -l .git/hooks/pre-commit

-rw-r--r-- 1 ana ana 46 Jul 31 13:02 .git/hooks/pre-commit

# 5. With execute permission
chmod +x .git/hooks/pre-commit
echo "z" >> f.txt
GIT_TRACE=1 git commit -am "hook test 2" 2>&1 | grep -i "pre-commit"

13:03:11.402 run-command.c:657  trace: run_command: '.git/hooks/pre-commit'
HOOK EXECUTED

# 6. GIT_TRACE_SETUP from a subdirectory
mkdir -p src/components && cd src/components
GIT_TRACE_SETUP=1 git status 2>&1 | head -6

13:04:22.101 trace.c:318  setup: git_dir: /tmp/p9-06b/.git
13:04:22.101 trace.c:319  setup: git_common_dir: /tmp/p9-06b/.git
13:04:22.101 trace.c:320  setup: worktree: /tmp/p9-06b
13:04:22.101 trace.c:321  setup: cwd: /tmp/p9-06b/src/components
13:04:22.101 trace.c:322  setup: prefix: src/components/

rm -rf /tmp/p9-06c && mkdir /tmp/p9-06c && cd /tmp/p9-06c && git init -q -b main
git config user.name "Ana Ferrer"; git config user.email "ana.ferrer@example.com"

cat > app.js <<'EOF'
function calculatePending(tasks) {
  return tasks.filter(t => !t.completed).length;
}
module.exports = { calculatePending };
EOF
git add . && git commit -q -m "GT-142 show the pending counter"

# 1. Twenty filler commits
for i in $(seq 1 20); do echo "// change $i" >> others.js; git add .; git commit -q -m "chore: change $i"; done

# 2. The culprit commit, with a message that explains the why
sed -i 's/!t.completed)/!t.completed || t.hidden)/' app.js
git commit -q -am "GT-231 add the hidden tasks filter

Archived tasks no longer appear in the list. The \`hidden\` flag is
added and filtered on in renderTasks().

The counter must carry on including them because the GT-231
specification says that \"pending\" counts every task that is not
completed, whether visible or not."
CULPRIT=$(git rev-parse --short HEAD)

# 3. Ten more commits
for i in $(seq 21 30); do echo "// change $i" >> others.js; git add .; git commit -q -m "chore: change $i"; done
git rev-list --count HEAD

32

# 4. The test
cat > /tmp/counter-test.sh <<'EOF'
#!/usr/bin/env bash
node -e '
  const { calculatePending } = require(process.cwd() + "/app.js");
  const tasks = [
    { completed: false, hidden: false },
    { completed: true,  hidden: false },
    { completed: false, hidden: true  }
  ];
  process.exit(calculatePending(tasks) === 2 ? 0 : 1);
' 2>/dev/null
EOF
chmod +x /tmp/counter-test.sh
/tmp/counter-test.sh; echo "current status: $?"

current status: 1

# 5. Bisect
git bisect start
git bisect bad HEAD
git bisect good HEAD~31
git bisect run /tmp/counter-test.sh 2>&1 | tail -12

Bisecting: 15 revisions left to test after this (roughly 4 steps)
running  '/tmp/counter-test.sh'
Bisecting: 7 revisions left to test after this (roughly 3 steps)
running  '/tmp/counter-test.sh'
Bisecting: 3 revisions left to test after this (roughly 2 steps)
running  '/tmp/counter-test.sh'
Bisecting: 1 revision left to test after this (roughly 1 step)
running  '/tmp/counter-test.sh'
4f8a2e6c9b1d5e3a7f2c8b6d9e4a1f5c3b7d2e9a is the first bad commit
    GT-231 add the hidden tasks filter
bisect found first bad commit

git bisect reset
echo "Expected culprit: $CULPRIT"

Expected culprit: 4f8a2e6

# 6. The function's history
git show 4f8a2e6 -- app.js

 function calculatePending(tasks) {
-  return tasks.filter(t => !t.completed).length;
+  return tasks.filter(t => !t.completed || t.hidden).length;
 }

git blame -L 1,3 app.js

4f8a2e6c (Ana Ferrer 2026-07-31 13:12:04 +0200 1) function calculatePending(tasks) {
4f8a2e6c (Ana Ferrer 2026-07-31 13:12:04 +0200 2)   return tasks.filter(t => !t.completed || t.hidden).length;
8a1f6c3d (Ana Ferrer 2026-07-31 13:11:58 +0200 3) }

git log -L :calculatePending:app.js --format='%h %ad %s' --date=short | grep -E '^commit|^[0-9a-f]{7} '

4f8a2e6 2026-07-31 GT-231 add the hidden tasks filter
8a1f6c3 2026-07-31 GT-142 show the pending counter

# 7. The why
git log -1 --format=%B 4f8a2e6

GT-231 add the hidden tasks filter

Archived tasks no longer appear in the list. The `hidden` flag is
added and filtered on in renderTasks().

The counter must carry on including them because the GT-231
specification says that "pending" counts every task that is not
completed, whether visible or not.