myxce/.claude/skills/weekly_report/SKILL.md

name	description	allowed-tools	argument-hint	triggers
weekly_report	Summarize last week's work status into a dated Markdown report. Use when the user asks for a weekly report, weekly summary, week-in-review, or status writeup for a past week.	Read, Write, Bash, Glob, Grep	<output-dir> [--week N] [--days mon-sat|mon-sun] [--author <name|email>]	/weekly_report weekly report weekly summary week in review

weekly_report Skill

Generate a work-status report for a completed week from repository evidence (git history, spec progress, bug log, session notes) and save it as <output-dir>/<mmmDD>-<mmmDD>-<YYYY>.md — e.g. jun29-jul04-2026.md.

Invocation

/weekly_report docs/reports            # last complete week -> docs/reports/aug10-aug15-2026.md
/weekly_report ~/reports --week 2      # two weeks back
/weekly_report docs/reports --days mon-sun
/weekly_report docs/reports --author rongsong.shen@gmail.com

Arguments

Arg	Default	Meaning
<output-dir>	.wolf/reports/	Directory the report is written to. Created if missing. Announce it when the default is used.
--week N	1	How many weeks back. 1 = last complete week, 2 = the one before, 0 = the current (partial) week.
--days	mon-sat	Work-week span. mon-sat = Mon..Sat (matches the established filename convention), mon-sun = Mon..Sun.
--author	(all)	Restrict git history to one author. Default includes every author, since agent-assisted commits are attributed to the human owner.

Procedure

Step 1 — Resolve the reporting window and filename

Run this first; everything downstream keys off $START, $END, and $SLUG.

Use python3, not date -d. The date first on PATH in this environment is BusyBox, which silently rejects relative expressions like -d "-7 days" and yields empty variables — producing a report over an unbounded window.

WEEK_OFFSET=1            # from --week: 1 = last complete week, 0 = current
SPAN_DAYS=5              # 5 => Mon..Sat (mon-sat), 6 => Mon..Sun (mon-sun)

eval "$(python3 - "$WEEK_OFFSET" "$SPAN_DAYS" <<'PY'
import sys, datetime
off, span = int(sys.argv[1]), int(sys.argv[2])
t = datetime.date.today()
start = t - datetime.timedelta(days=t.weekday()) - datetime.timedelta(weeks=off)
end = start + datetime.timedelta(days=span)
f = lambda d: d.strftime('%b%d').lower()
print(f'START={start}\nEND={end}\nSLUG={f(start)}-{f(end)}-{end.year}')
PY
)"
echo "window: $START .. $END  ->  ${SLUG}.md"

Filename rules:

• Lowercase 3-letter month + zero-padded day, both endpoints, then the end date's year — jun29-jul04-2026.md. A window straddling New Year (dec28..jan02) is therefore dec28-jan02-2027.md.
• Sanity-check the output before continuing: $START must be a Monday and both $START/$END must be non-empty. Empty values mean the date math failed — stop rather than running git queries with an unbounded --since.

Before writing, check for a collision:

test -e "$OUT_DIR/$SLUG.md" && echo "EXISTS — do not overwrite without asking"

If the file already exists, tell the user and ask whether to overwrite before proceeding. Do not silently replace a prior report.

Step 1b — Continuity check: report the GAP, not the calendar default

Do this before gathering any evidence. The naive "last complete ISO week" is frequently the wrong window, because this series is written whenever the user asks, not on a fixed cadence — so the previous report often already covers part or all of it.

ls -1 "$OUT_DIR"/*.md 2>/dev/null | sort

Parse the end date of the most recent existing report (from its filename and its # ... — <range> heading, which is authoritative when the two disagree). Then:

• If the last report's end date is ≥ your computed $END, the default window is already covered. Shift the window to last_end + 1 day .. the most recent completed day, and rename $SLUG to match.
• If there is a gap between the last report's end and your computed $START, the gap is the real reporting window — covering it is the point of the series.
• Only fall through to the plain ISO default when no prior report exists.

Announce the adjustment and why. Real example (2026-08-23): the ISO default resolved to Aug 10–15, but aug08-aug15-2026.md already covered it; the genuine gap was Aug 16–22, and reporting the default would have produced a duplicate while leaving a week unreported.

Windows in this series are therefore not always Mon–Sat — they are previous_end + 1 .. last completed day. Historical filenames confirm the drift (jul19-jul26, aug08-aug15). Continuity beats calendar tidiness.

Step 2 — Gather git activity

--all walks every local branch, so sibling worktrees of the same repository are covered by one query. Add --author="$AUTHOR" to each command when --author was passed.

# Commit list
git log --all --no-merges --since="$START 00:00:00" --until="$END 23:59:59" \
  --date=format:'%a %m-%d' --pretty=format:'%h%x09%ad%x09%an%x09%s'

# Volume — headline figure EXCLUDES .wolf/ bookkeeping, which otherwise dominates
# (one real week: +288,983 raw vs +28,657 real, from token-ledger.json alone)
git log --all --no-merges --since="$START 00:00:00" --until="$END 23:59:59" \
  --pretty=tformat: --numstat -- . ':(exclude).wolf/*' |
  awk '{a+=$1; d+=$2; n++} END {printf "%d file-changes, +%d / -%d (non-wolf)\n", n, a, d}'

# Real vs bookkeeping commit split
tot=$(git log --all --no-merges --since="$START 00:00:00" --until="$END 23:59:59" --pretty=format:'%s' | wc -l)
real=$(git log --all --no-merges --since="$START 00:00:00" --until="$END 23:59:59" --pretty=format:'%s' \
  | grep -vc '^chore(wolf)\|^save wolf\|^commit wolf\|^chore: sync harness')
echo "$tot commits total, $real real, $((tot-real)) wolf bookkeeping"

# Where the work landed (component buckets)
git log --all --no-merges --since="$START 00:00:00" --until="$END 23:59:59" \
  --name-only --pretty=format: | grep -v '^$' | sort -u |
  awk -F/ '{print ($1=="src" ? "src/"$2 : $1)}' | sort | uniq -c | sort -rn

# Conventional-commit scopes (maps commits to features/specs)
git log --all --no-merges --since="$START 00:00:00" --until="$END 23:59:59" \
  --pretty=format:'%s' | sed -n 's/^[a-z]*(\([^)]*\)).*/\1/p' | sort | uniq -c | sort -rn

# Branches that received commits in the window
git log --all --no-merges --since="$START 00:00:00" --until="$END 23:59:59" \
  --pretty=format:'%H' | while read -r c; do
    git branch -a --contains "$c" --format='%(refname:short)'; done | sort -u

Read commit bodies (git show -s --format=%B <sha>) only for commits whose subject is too terse to classify — do not dump every body into context.

Step 3 — Gather spec progress

Find specs touched during the window, then compute their task completion:

git log --all --no-merges --since="$START 00:00:00" --until="$END 23:59:59" \
  --name-only --pretty=format: | grep '^\.kiro/specs/' | cut -d/ -f3 | sort -u

For each spec name found:

d=".kiro/specs/$name"
jq -r '"phase=\(.phase) ready=\(.ready_for_implementation) blocked=\(.blocked_on // [] | join(","))"' "$d/spec.json"
[ -f "$d/tasks.md" ] && printf '%s tasks: %s/%s done\n' "$name" \
  "$(grep -cE '^\s*- \[x\]' "$d/tasks.md")" "$(grep -cE '^\s*- \[[ x]\]' "$d/tasks.md")"

To attribute which tasks were completed in the window, diff tasks.md across the window boundary rather than reading the current file alone:

git log --all --since="$START 00:00:00" --until="$END 23:59:59" -p \
  -- ".kiro/specs/$name/tasks.md" | grep -E '^\+\s*- \[x\]'

Step 4 — Gather bug activity

jq -r --arg s "$START" --arg e "$END" '
  .bugs[]
  | select((.timestamp[0:10]      >= $s and .timestamp[0:10]      <= $e)
        or ((.last_seen // "")[0:10] >= $s and (.last_seen // "")[0:10] <= $e))
  | [ .id,
      .timestamp[0:10],
      (if (.fix // "") == "" then "OPEN" else "FIXED" end),
      (.tags // [] | join(",")),
      (.error_message // "")[0:110]
    ] | @tsv
' .wolf/buglog.json

Report opened-vs-fixed counts and call out any entry still OPEN at window end — those are carry-over risk.

Two corrections this query needs:

Duplicate IDs. .wolf/buglog.json has a history of counter restarts, so an in-window .timestamp on a low ID does not mean an old bug was re-touched — it usually means a new entry was appended under an already-used ID. Separate genuinely-new IDs from collisions, and report the collision count as an integrity finding:

# genuinely new (above the prior max) vs collisions
jq -r --arg s "$START" --arg e "$END" --argjson floor 1561 '
  [.bugs[]|select(.timestamp[0:10]>=$s and .timestamp[0:10]<=$e)
   |.id|capture("^bug-(?<n>[0-9]+)").n|tonumber] | unique
  | {new: map(select(.>=$floor))|length, collisions: map(select(.<$floor))|length}' .wolf/buglog.json

# current duplicate-ID census
jq -r '[.bugs[].id]|group_by(.)|map(select(length>1))|length' .wolf/buglog.json

Set $floor to one above the max ID present in the prior report's range.

Carry-over resolution. Re-check every bug the previous report listed as open and state its status now — that closing-the-loop line is the series' main continuity value.

Step 5 — Gather session notes (optional enrichment)

.wolf/memory.md is large. Extract only session headers inside the window first, and read row detail only where git history is thin on explanation:

awk -v s="$START" -v e="$END" '
  /^## Session: /{ d=substr($3,1,10); keep = (d>=s && d<=e); if (keep) print; next }
  keep && /^\| [0-9]/ { c[d]++ }
  END { for (k in c) printf "  %s: %d logged actions\n", k, c[k] }
' .wolf/memory.md

If the claude-mem MCP tools are available, timeline scoped to the window adds narrative context for decisions that never produced a commit. Treat this as optional — never block the report on it.

Step 6 — Compose the report

Write to $OUT_DIR/$SLUG.md. Match the established format of this series — read the most recent existing report first and mirror its section order. As of Aug 2026 that format is stable across the last three reports:

# XCE Project Status — <Mon DD> – <Mon DD>, <YYYY>

## TL;DR

<3-5 sentences: the window's theme, what shipped, what regressed. Written so someone
who missed the week understands the state without reading further.>

## Commits by day

### <Mon DD> (<Day>) — <theme for that day>

- **`<sha>`** — <what it did and why it matters>

## Bugs opened/fixed this window

- **N new bugs** (bug-X – bug-Y), **M fixed**, **K still open**
- Carry-over status: which of the *prior report's* open bugs are now closed
- Highest-severity fixes, named
- ⚠️ Any integrity/regression concern about the bug log itself

## Spec status changes

- **<spec>** — <phase transition, task count, and any metadata/reality mismatch>

## Stats

- **N commits** — split feature/fix/docs vs `.wolf` bookkeeping
- **N files changed**, **+A / −D** — quote the non-`.wolf` figure as the headline
- Busiest areas, specs completed, sessions logged

## Open threads / to-do heading into next session

1. <numbered, actionable, with enough detail to resume cold>

Report-writing rules:

• Evidence-backed only. Every claim traces to a commit, spec file, or bug entry. Do not infer progress that has no artifact.
• Cite short SHAs inline so the reader can jump to the diff.
• Day sections get a theme, not a commit dump — group the day's commits under what the day was actually about ("HA + dispatch firefight", "spec to done in one day").
• Close the loop on the prior report's open threads. Explicitly state which were resolved and which carried over — that continuity is the series' main value.
• Quote non-.wolf line counts as the headline. .wolf/token-ledger.json and buglog.json churn dwarfs real code (one week: +288,983 raw vs +28,657 real). Exclude with -- . ':(exclude).wolf/*' and mention the raw figure parenthetically.
• Separate bookkeeping commits from real ones in the count — chore(wolf) checkpoints were 89 of 192 commits in one window.
• Language: English, unless a spec's spec.json language field says otherwise.
• Numbered open threads carry forward; write them so a cold session can act on them.

Step 7 — Save and confirm

mkdir -p "$OUT_DIR"

Write the file with the Write tool, then report back to the user in one or two sentences: the path written, the window covered, and the headline counts (commits / specs advanced / bugs fixed).

Safety & Fallback

Not a git repository — report that git evidence is unavailable and build the report from .wolf/memory.md, .wolf/buglog.json, and .kiro/specs/ alone. Note the limitation in the report header.

Empty window (no commits, no bug entries, no sessions) — do not fabricate content. Write a short report stating no recorded activity, and ask whether the window was intended (a wrong --week offset is the usual cause).

Missing .wolf/ or .kiro/ — skip those sections silently; git history alone is a valid basis for the report.

Existing report file — ask before overwriting (see Step 1).

After Running

Per the OpenWolf protocol, append a one-line entry to .wolf/memory.md recording the report generation, and add the new report file to .wolf/anatomy.md.