Backed by: state/lib/log.ts (reads state/log/evals.ndjson)

polish-digest

Reads state/log/evals.ndjson, filters to skill == "content-polish" and ts >= since. Groups by primary_issue, counts occurrences, emits the top N. This is the feedback loop - without it, voice.checkTone() doesn't get tuned.

Steps

1. Tail-read evals.ndjson.
2. Filter to content-polish rows in window.
3. Group by primary_issue (split on ; for multi-issue rows).
4. Sort by count descending.
5. Emit state/log/polish-digest/<date>.md - top violations, first-try

pass rate, average turns_used.

Eval

Actor: the aggregation logic that writes <date>.md. Auditor: independent re-read of the produced digest from disk (outcome gate), backstopped by the row-count shape check.

Outcome gate (the load-bearing assertion)

Pod K's audit (commit ae19fee) flagged the prior shape-only gate as a cheater - it scored 1.0 simply because the script ran. The real question is: does the digest CONTAIN the expected sections with non-empty content? If not, no downstream consumer can act on it.

After writing the digest, the script re-reads it from disk and validates each required section header is present AND has at least one non-blank, non-header line of content beneath it.

Required sections (every digest must have all four):

Validation contract:

const REQUIRED_SECTIONS = [
  "## Summary", "## Violation breakdown",
  "## Em-dash canary", "## Drift signal",
];
const onDisk = readFileSync(digestPath, "utf-8");
// parse: collect non-blank, non-header lines under each "## " header
// missing[] = required headers absent from file
// empty[]   = required headers present but with zero content lines
const outcomeOk = missing.length === 0 && empty.length === 0;

If outcomeOk === false, score is 0.0 with primary_issue set to missing-sections:<csv> or empty-sections:<csv>. No partial credit - a digest with a missing section is not actionable.

Shape gate (precondition, retained)

If the outcome gate passes, the prior shape gate (row-count parity + violation-sum sanity) determines whether the score is 1.0 or 0.5:

const raw_polish_rows = evals_ndjson.filter(r => r.skill === "content-polish" && r.ts >= since).length;
const parsed_eq_raw = rows_read === raw_polish_rows;
const violations_sum_to_total = sortedIssues.reduce((a, i) => a + i.count, 0) >= rows_read - firstTryPass;

// Combined logic (outcome gate first, shape gate second):
let scoreVal =
  raw_polish_rows === 0 && reason_empty ? 1.0 :
  raw_polish_rows === 0 && !reason_empty ? 0.0 :
  parsed_eq_raw && violations_sum_to_total ? 1.0 :
  parsed_eq_raw ? 0.5 :
  0.0;
if (!outcomeOk) { scoreVal = 0.0; primaryIssue = `missing-sections:${missing.join(",")}` || `empty-sections:${empty.join(",")}`; }

Logged fields (outcome_gate):

{
  "required_sections": ["Summary", "Violation breakdown", "Em-dash canary", "Drift signal"],
  "missing": [],
  "empty": [],
  "ok": true
}

This skill's output IS the signal for evolving voice.ts. If the same violation dominates two weeks running, the rewrite-prompt isn't teaching the model; tune it.

Gotchas

• Ignore rows with score: 1.0 and primary_issue: null - those are

clean first-try passes, not drift signal.

• Count em-dash as its own bucket - it's the canary.

polish-digest - loader

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

Critical Rules

• IGNORE rows with score: 1.0 AND primary_issue: null - those are clean first-try passes, not drift signal
• Count em-dash as its own violation bucket - it's the canary for voice drift
• This skill's output IS the signal for evolving voice.ts. If the same violation dominates two weeks running, the rewrite-prompt isn't teaching the model - tune it.
• Multi-issue rows (;-joined primary_issue) must SPLIT before grouping; otherwise the bucket counts will undercount each individual violation
• An empty digest window MUST set reason_empty - a silent empty (zero rows, no reason) scores 0.0 (primary_issue: "silent-empty")

Commands

|invoke: skill is prose - follow steps 1-5 in state/skills/polish-digest.md |backed by: state/lib/log.ts (reads state/log/evals.ndjson) |output: state/log/polish-digest/<date>.md |eval log: state/log/evals.ndjson (skill: "polish-digest")

Known Pitfalls

• parsed_eq_raw mismatch (rows_read != raw_polish_rows) scores 0.0 with primary_issue: "row-count-mismatch" - usually means a parse or filter regression, NOT a voice problem
• violations_sum_to_total gap (sum of issue counts < total fails) scores 0.5 with primary_issue: "violation-count-gap" - can mean missing splits on ;
• Window default is 14 days; tune via since: <ISO date> input

Self-Test

An agent reading this should correctly:

1. [ ] Filter out clean-pass rows (score: 1.0, primary_issue: null) before counting?
2. [ ] Split multi-issue rows on ; before grouping by violation bucket?
3. [ ] Set reason_empty on a zero-row digest to avoid silent-empty?

Self-report

If this loader fell short, append a line:

echo "[$(date -u +%FT%TZ)] polish-digest: <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.