Backed by: state/lib/log.ts (pure git log wrapper; no network lib needed)

commit-report

git log --since=$since --format across active ~/projects/snappy-* repos. Parses conventional-commits prefixes (feat:/fix:/refactor:/ chore:/docs:). Emits a per-repo, per-scope table.

Steps

1. List active repos. A repo counts as active ONLY if

git rev-list --count --since=$since HEAD > 0. Reject zero-commit repos here - including them triggers empty-repo-in-report at eval time. The 2026-04-18 failure run included snappy-ops with 0 commits; the filter must happen at step 1, not after.

1. Dispatch per-repo git log calls in parallel.
2. Parse commits, group by scope.
3. Write state/log/commit-report/<date>.md. If the final report has

zero total commits across all repos (legitimate quiet day), you MUST populate reason_empty in the eval row with a concrete string (e.g. "no repos had commits since $since"). Omitting reason_empty on an empty report is the silent-empty failure mode - it scores 0.0.

Eval

Actor: git log parser + grouper. Auditor: raw commit count cross-check vs git rev-list --count.

const raw_count = repos.reduce((a, r) => a + revListCount(r, since), 0);
const parsed_count = commits.length;
const all_parsed = parsed_count === raw_count;
const no_empty_repos = repos.every(r => commitsByRepo[r].length > 0);

score("commit-report", run_id, {
  score:
    raw_count === 0 && reason_empty ? 1.0 :
    raw_count === 0 && !reason_empty ? 0.0 :
    all_parsed && no_empty_repos ? 1.0 :
    all_parsed ? 0.5 :
    0.0,
  repo_count: repos.length,
  commit_count: parsed_count,
  raw_count,
  by_scope: scopeCounts,
  primary_issue:
    raw_count === 0 && !reason_empty ? "silent-empty" :
    !all_parsed ? `missed-${raw_count - parsed_count}-commits` :
    !no_empty_repos ? "empty-repo-in-report" : null,
});

Cross-checks parsed commit count against raw git rev-list --count. Silent empty or missed commits score 0.0/0.5 respectively.

Gotchas

• Non-conventional commits go into scope: "other". Don't drop them.
• If a repo is dirty or in a rebase, log the state and skip rather than

fail.

• Filter before listing, not after. The active-repo filter belongs

at step 1 (rev-list --count > 0). If you collect all snappy-* dirs first and filter later, you'll emit a table row for an idle repo - the 2026-04-18 snappy-ops idle (0 commits) failure came from exactly this.

• Silent-empty scores 0.0, not "ok". An empty report without

reason_empty in the eval row is treated as a scoring bug, not a quiet day. Always populate reason_empty on a zero-commit day.

commit-report - loader

Per-turn rules for the commit-report skill. Full reference: state/skills/commit-report.md. Do not skip these.

Critical Rules

• NEVER drop non-conventional commits - they go into scope: "other"
• NEVER hard-fail on a dirty repo or in-rebase state - log the state and skip that repo, continue with the rest
• ALWAYS cross-check parsed commits.length against raw git rev-list --count - a mismatch is missed-N-commits and scores 0.5
• ALWAYS distinguish silent-empty (no commits, no reason) → 0.0 vs reason-empty (no commits, reason logged) → 1.0

Commands

|invoke: list active repos (commit in last 14d), parallel git log --since=$since --format per repo, parse + group, write state/log/commit-report/<date>.md |verify: all_parsed && no_empty_repos → 1.0; all_parsed only → 0.5; else 0.0 |eval log: state/log/evals.ndjson (skill: "commit-report")

Known Pitfalls

• Active-repo definition is "commit in last 14 days." Don't widen to all snappy-* dirs - dormant repos pollute the report.
• no_empty_repos is part of the 1.0 gate - a listed repo with zero commits in window is empty-repo-in-report and drops to 0.5.

Self-Test

An agent reading this should correctly:

1. [ ] Send a chore: commit with no scope into scope: "other" rather than dropping it
2. [ ] Skip a dirty repo with a log line, not abort
3. [ ] Distinguish silent-empty from reason-empty in scoring

Self-report

If this loader fell short, append a line:

echo "[$(date -u +%FT%TZ)] commit-report: <what was missing>" >> ~/.claude/logs/snappy-os-loader-feedback.log

<!-- kernel-ok: historical attribution for the PID-loader pattern. -->

Self-correcting loader (PID feedback)

This is the rule that makes loaders learn. Ported from snappy-kernel, where it demonstrably worked: the snappy-dom-cartographer skill mapped Skool admin UI once, every later ship-agent inherited the full map for free.

Before you finish, do two things:

1. Fix gaps (P - proportional). MANDATORY. If this loader didn't cover your case - if you had to read another file, run an undocumented command, work around a wrong selector, or discover a quirk - you MUST attempt an Edit to this .agents.md before you log.

• Default action: edit this file. Surgical. Add the missing line, table

row, or code example where it belongs. No restructuring.

• Only LOGGED is allowed when: the fix needs >10 lines, spans multiple

files, or requires a structural rewrite. In that case the state/regen/drain.sh queue picks it up asynchronously.

• "I didn't have time" / "it's minor" / "the next agent will figure it out"

are NOT valid reasons. Minor gaps compound - that's the whole point of this loop.

• Concrete example of a valid P-fix: discover agent-browser screenshot

takes path positionally not as --output <path>. One line in a table. Edit it in. Do not just log it.

• The goal: the next agent never has to leave the loader.

2. Log the result.

echo "[$(date -u +%FT%TZ)] <skill-name>: <what was missing or fixed> [FIXED|LOGGED]" >> state/log/agents-md-feedback.log

• FIXED = you patched this loader inline (P-fix).
• LOGGED = too large for inline; the PostToolUse enqueue + Stop-hook drain

will rewrite the loader from scratch on next session-end.

Do not skip this. Every agent run must leave the system better than it found it. The loader is the setpoint; you are the sensor; the gap is the error signal; closing the gap is the correction.