cd /mnt/c/Users/$USER/02_Areas/AI && claude   # writes ~/.claude/projects/-mnt-c-Users-...-02-Areas-AI/
cd /mnt/c/Users/$USER/02_Areas/ai && claude   # writes ~/.claude/projects/-mnt-c-Users-...-02-Areas-ai/
# Same on-disk directory. Two project dirs. /resume only sees one.

---

$ ~/.claude/scripts/claude-projects-audit.sh
Duplicate-history audit for /home/robert/.claude/projects
Resolver: walk filesystem (dash = '/' or '_'), then realpath()
Today: 2026-05-25 10:10:12

=== Resolves to: PARTIAL:/mnt/c/users/rhamm/02_areas/ai  (2 members) ===
  [PARTIAL ] -mnt-c-Users-rhamm-02-Areas-AI    sessions=1    latest=2026-05-01 17:42:12
  [PARTIAL ] -mnt-c-Users-rhamm-02-Areas-ai    sessions=2    latest=2026-05-01 17:42:09

Summary: 9 project dir(s) scanned, 1 duplicate group(s) covering 2 dir(s).

---

#!/usr/bin/env bash
# claude-projects-audit.sh
#
# Read-only audit of ~/.claude/projects/ for fragmented per-cwd history dirs.
#
# Claude Code keys each project's history directory on the literal cwd string
# at launch (not realpath(cwd)). On WSL+DrvFs, where NTFS is case-insensitive
# at the FS layer but case-sensitive at the string layer, the same on-disk
# directory can be addressed by multiple cwd strings, silently splitting
# history. Symlinks and other normalizations cause the same class of bug.
#
# Encoding scheme used by Claude Code (best understood from observed data,
# *not* a clean bijection):
#   - Leading '/'   -> leading '-'
#   - Each '/'      -> '-'
#   - Each '_'      -> '-'   (!)
#   - Case preserved
# Because both '/' and '_' become '-', the encoded form is ambiguous and
# the only reliable decoder consults the filesystem.

set -euo pipefail

PROJECTS_DIR="${HOME}/.claude/projects"

if [[ ! -d "$PROJECTS_DIR" ]]; then
    echo "No projects dir at $PROJECTS_DIR" >&2
    exit 1
fi

encoded_list=()
for d in "$PROJECTS_DIR"/*/; do
    [[ -d "$d" ]] || continue
    encoded_list+=("$(basename "$d")")
done

if (( ${#encoded_list[@]} == 0 )); then
    echo "No project dirs found under $PROJECTS_DIR" >&2
    exit 0
fi

resolve_tsv=$(python3 - "${encoded_list[@]}" <<'PY'
import os, sys

def walk(prefix, parts, i):
    """Resolve parts[i:] as far as the filesystem allows.

    Returns (best_prefix, parts_unconsumed). When parts_unconsumed is
    empty, the path resolved fully. Otherwise best_prefix is the
    deepest existing directory we could reach and parts_unconsumed are
    the tokens we couldn't place (typically because they sit beyond a
    broken or unreadable symlink — common on WSL DrvFs when the link
    points across the WSL/Windows boundary).
    """
    if i >= len(parts):
        return prefix, []
    best = (prefix, parts[i:])
    best_consumed = 0
    for n in range(len(parts) - i, 0, -1):
        seg = '_'.join(parts[i:i+n])
        cand = os.path.join(prefix or '/', seg)
        try:
            is_dir = os.path.isdir(cand)
        except OSError:
            is_dir = False
        if not is_dir:
            continue
        sub_prefix, sub_remaining = walk(cand, parts, i + n)
        consumed = (len(parts) - i) - len(sub_remaining)
        if consumed > best_consumed:
            best = (sub_prefix, sub_remaining)
            best_consumed = consumed
        if not sub_remaining:
            return best
    return best

for enc in sys.argv[1:]:
    enc = enc.strip()
    if not enc:
        continue
    parts = enc.lstrip('-').split('-')
    resolved_prefix, remaining = walk('', parts, 0)
    if not remaining:
        try:
            key = os.path.realpath(resolved_prefix)
        except OSError:
            key = resolved_prefix
        status = 'RESOLVED'
    else:
        partial = os.path.join(resolved_prefix or '/', '/'.join(remaining))
        key = 'PARTIAL:' + partial.casefold()
        status = 'PARTIAL'
    print(f"{enc}\t{key}\t{status}")
PY
)

TMP=$(mktemp)
trap 'rm -f "$TMP"' EXIT

while IFS=$'\t' read -r enc key status; do
    [[ -z "$enc" ]] && continue
    dir="$PROJECTS_DIR/$enc"
    sessions=$(find "$dir" -maxdepth 1 -name '*.jsonl' -type f 2>/dev/null | wc -l)
    latest_epoch=$(find "$dir" -type f -printf '%T@\n' 2>/dev/null | sort -rn | head -n1)
    if [[ -n "$latest_epoch" ]]; then
        latest=$(date -d "@${latest_epoch%.*}" '+%Y-%m-%d %H:%M:%S')
    else
        latest="(empty)"
    fi
    printf '%s\t%s\t%d\t%s\t%s\n' "$key" "$enc" "$sessions" "$latest" "$status" >> "$TMP"
done <<< "$resolve_tsv"

echo "Duplicate-history audit for $PROJECTS_DIR"
echo "Resolver: walk filesystem (dash = '/' or '_'), then realpath()"
echo "Today: $(date '+%Y-%m-%d %H:%M:%S')"
echo

dup_groups=0
dup_dirs=0
while IFS= read -r key; do
    count=$(awk -F'\t' -v k="$key" '$1==k' "$TMP" | wc -l)
    if (( count > 1 )); then
        dup_groups=$((dup_groups + 1))
        dup_dirs=$((dup_dirs + count))
        echo "=== Resolves to: $key  ($count members) ==="
        awk -F'\t' -v k="$key" '$1==k {
            printf "  [%-8s] %-50s  sessions=%-4s  latest=%s\n", $5, $2, $3, $4
        }' "$TMP" | sort
        echo
    fi
done < <(cut -f1 "$TMP" | sort -u)

total=$(wc -l < "$TMP")
echo "Summary: $total project dir(s) scanned, $dup_groups duplicate group(s) covering $dup_dirs dir(s)."
if (( dup_groups == 0 )); then
    echo "No fragmentation detected."
fi

echo
echo "All entries (key -> encoded, sessions, latest, status):"
sort "$TMP" | awk -F'\t' '{
    printf "  %-60s  %-46s  sessions=%-4s  latest=%-19s  [%s]\n", $1, $2, $3, $4, $5
}'