chore(skills): wire solidstats-process-skill-feedback; refresh project-standards (#33)

Adds the new self-improvement loop skill and refreshes solidstats-shared-project-standards (§A active-suggestion hook).

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Afgan0r

.agents/skills/solidstats-process-skill-feedback/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog — solidstats-process-skill-feedback
+
+## v1.0 — 2026-06-22 — initial skill
+
+- New direct-invoke (`disable-model-invocation`) process skill: the SolidStats self-improvement loop
+  for the artefactual `solidstats-*` skills (conventions / code-review / tests / shared-*-standards).
+- Sibling of `estesis-process-review-feedback`, diverging on three deliberate decisions:
+  - **Signal** — learns from *agent-discovered-during-work* divergence (skill wrong / incomplete /
+    caused a bug), not only human edits to AI reviews. Five signals: divergence, gap, caused-bug,
+    friction, preference.
+  - **Threshold** — hybrid fact/preference: a **fact** promotes at one occurrence; a **preference**
+    promotes at three (rule of three). The `class` field is load-bearing.
+  - **Journal location** — in the canonical `solid-stats/skills` repo (`<skill>/corrections-log.md` +
+    `regression-evals.jsonl`), committed next to the skill, no separate corrections repo and no ENV
+    var (this repo is the source of truth the promotion edits). CAPTURE resolves that canonical
+    checkout explicitly (§H) — the witness usually works in a *consuming* repo where the running copy
+    is the vendored `.agents/skills/**` (wiped on sync), so the journal must never be written there.
+- Two modes: CAPTURE (per discovery; entry point via `capture-session-lessons` routing or the
+  active-suggestion offer) and PROMOTE (batch, manual; applies the edit in-repo on user approval,
+  leaves the commit to the user).
+- Boundary with MemPalace/memory: the one-question test — *would fixing this edit a `solidstats-*`
+  SKILL.md?* — keeps skill-rule corrections here and product/code facts in MemPalace.
+- Active-suggestion protocol documented (§E); the proactive offer is wired into
+  `solidstats-shared-project-standards` (auto-fires on every task), since this skill never
+  auto-triggers.
+- Files: SKILL.md, workflows/{capture,promote}.md, references/{signal-taxonomy,journal-schema}.md,
+  templates/correction-entry.md.

.agents/skills/solidstats-process-skill-feedback/SKILL.md

@@ -0,0 +1,106 @@
+# Journal schema, cluster signature, and regression-eval shape
+
+This is the contract the loop depends on. Capture writes it; promote reads it. Keep entries
+machine-parseable (stable field names) **and** human-readable — the log is a Markdown file the team
+diffs in git, next to the skill it teaches.
+
+## Table of contents
+- [1. The normalized correction entry](#1-the-normalized-correction-entry)
+- [2. Field reference](#2-field-reference)
+- [3. The cluster signature](#3-the-cluster-signature)
+- [4. The regression-eval case](#4-the-regression-eval-case)
+
+---
+
+## 1. The normalized correction entry
+
+Each correction is one block appended to `<target-skill>/corrections-log.md` (in this skills repo).
+A Markdown heading for scanning, a YAML fence for parsing.
+
+```markdown
+### SC-2026-06-22-a3f9 · divergence · fact · §4
+
+```yaml
+id: SC-2026-06-22-a3f9
+date: 2026-06-22
+target_skill: solidstats-server-ts-conventions
+repo: server-2                 # server-2 | replays-fetcher | replay-parser-2 | web | n-a
+source: agent-discovered       # agent-discovered | human-edit | free-form-prose
+signal: divergence             # divergence | gap | caused-bug | friction | preference
+class: fact                    # fact (promote@1) | preference (promote@3)
+generalized: false             # true only for a stated principle, not an instance
+section: "§4"                  # target skill's section/slug, or "unmapped"
+topic: di                      # short tag
+dev_change: >
+  Conventions §4 says deps are wired in deps.py, but server-2 wires them in di/ (see
+  src/di/container.ts). The rule names a file that does not exist in this repo.
+code:
+  file: "src/di/container.ts"
+  line: 1
+  source: agent-snippet        # agent-snippet | head-besteffort | none
+  status: positive-example     # negative-example | positive-example | needs-code-context | n-a
+  snippet: |
+    export const container = buildContainer({ ... })
+rationale: >
+  Pure factual error — the skill points at a path that isn't there. Fixable at one occurrence.
+status: open                   # open | promoted | discarded
+signature: "divergence|§4|deps wired in di/ not deps.py"
+```
+```
+
+> The example shows a real ```` ```yaml ```` fence nested in this doc; write it normally in the log.
+
+## 2. Field reference
+
+| Field | Meaning | Notes |
+|-------|---------|-------|
+| `id` | `SC-<date>-<4-hex>` | Stable; lets a promotion cite exact sources |
+| `target_skill` | Which skill this teaches | Resolved per SKILL.md §C; must be in-scope |
+| `repo` | Which consuming repo surfaced it | Provenance; `n-a` for a shared-standard-only fact |
+| `source` | How it arrived | `agent-discovered` is the SolidStats norm |
+| `signal` | One of the five | `references/signal-taxonomy.md` §2 |
+| `class` | `fact` or `preference` | **Drives the threshold** — §A.3 of SKILL.md |
+| `generalized` | A stated rule, not an instance | Relaxes the code requirement |
+| `section` | Target skill's section slot | `unmapped` if it fits no section (signals the taxonomy may need one) |
+| `dev_change` | The core observation: what the skill said vs. what is true | For `divergence` this carries the true fact |
+| `code.*` | Bound code | §G of SKILL.md — source priority and the HEAD caveat |
+| `code.status` | How to read the snippet | `negative-example` = should-flag; `positive-example` = should-not-flag/already-correct |
+| `rationale` | The "why" + the class reasoning | Decisive at promotion |
+| `status` | Lifecycle | `open` until promoted or discarded |
+| `signature` | Cluster key | See below |
+
+## 3. The cluster signature
+
+The rule of three (for preferences) counts **patterns**, not byte-identical entries. The signature
+is the cluster key:
+
+```
+signature = "<signal>|<section>|<canonical-description>"
+```
+
+- `signal` and `section` are exact-match buckets.
+- `canonical-description` is a short normalized phrase for *the same underlying issue*, written so
+  three phrasings collapse to one. "deps wired in di/ not deps.py" should absorb "deps.py is wrong,
+  it's di/" and "container lives in di/, conventions say deps.py".
+
+At promote time, clustering is **semantic**: group entries whose `(signal, section)` match and whose
+descriptions mean the same thing, then show the cluster to the user before counting it. `fact`
+entries do not need clustering to reach a count (they promote at one) — but still de-dup so a single
+fact logged twice isn't proposed twice.
+
+## 4. The regression-eval case
+
+Optional, recommended for `code-review`/`conventions` targets. When a capture binds code, append one
+JSON object (one line) to `<target-skill>/regression-evals.jsonl`:
+
+```json
+{"id": "SC-2026-06-22-a3f9", "section": "§4", "expect": "should-not-flag", "input_file": "src/di/container.ts", "snippet": "export const container = buildContainer({ ... })", "note": "deps wired in di/ not deps.py"}
+```
+
+- `expect`: `should-flag` (from a `gap`/`caused-bug` negative example) or `should-not-flag` (from a
+  positive example / corrected code).
+- `severity`: expected bucket when `should-flag`; omit otherwise.
+- `id` ties the case back to its journal entry so a promotion can graduate it into the target skill's
+  core `evals/evals.json` when the rule lands.
+
+These run on demand or right before a promotion — never on an always-run path.

.agents/skills/solidstats-process-skill-feedback/references/journal-schema.md

@@ -0,0 +1,95 @@
+# Signal taxonomy and the fact/preference class
+
+Capture sets two fields that drive everything downstream: `signal` (what kind of divergence) and
+`class` (fact or preference, which sets the promotion threshold). This file defines both and how each
+signal routes.
+
+## Table of contents
+- [1. The two classes](#1-the-two-classes)
+- [2. The five signals](#2-the-five-signals)
+- [3. Assigning the class](#3-assigning-the-class)
+- [4. Routing each signal at promote](#4-routing-each-signal-at-promote)
+
+---
+
+## 1. The two classes
+
+The class is the single most important field — it decides whether one occurrence is enough.
+
+- **fact** — objectively verifiable as right or wrong. The skill names a path/import/method/command
+  that does not exist or is wrong; the skill contradicts itself; following the skill produced a bug.
+  A known falsehood does not need three repeats to be worth fixing. → **eligible to promote at one
+  occurrence.**
+- **preference** — taste or style with no hard correctness. "Better to name it this way", "this rule
+  reads ambiguously", "I'd structure this differently." One witness is a noisy sample. → **promote
+  only after three** (rule of three).
+
+When genuinely unsure, default to **preference** — the cost of waiting for a second witness is low;
+the cost of rewriting a shared skill from one opinion is high.
+
+## 2. The five signals
+
+### divergence — the skill is wrong about a fact
+The skill states X; the real code or the correct practice is Y. The classic case: a convention names
+a file/dir/import/method that the repo does not use.
+- Class: **fact**.
+- Evidence: the *true* fact (the real path/method), not necessarily a code snippet. Record it in
+  `dev_change`; add a `file:line` in the consuming repo if one proves it.
+- Example: `solidstats-server-ts-conventions` says deps live in `deps.py`; server-2 wires them in
+  `di/`.
+
+### gap — a real pattern no rule covers
+Working in the repo surfaces a recurring pattern the skill is silent on. Not that the skill is wrong
+— that it is incomplete.
+- Class: **fact** when the pattern is canonical/agreed (it is simply missing); **preference** when
+  it is a judgment call about whether the pattern *should* be the standard.
+- Evidence: the pattern, with code.
+- Example: every service in server-2 wraps external calls in a typed adapter, but no conventions rule
+  states it.
+
+### caused-bug — following the rule produced a defect
+The agent obeyed the skill and the result was a bug, or the rule actively steers toward one.
+- Class: **fact**. This is the highest-value signal — a rule that causes bugs is worse than a missing
+  rule.
+- Evidence: the offending code **and** the bug (symptom or failing test).
+- Routing: qualify or fix the rule, and prefer adding a guardrail (a "don't do X because it causes
+  Y" note) over a bare deletion.
+
+### friction — the rule is ambiguous or contradictory
+The rule is unclear, internally contradictory, or contradicts another rule, and that cost real time.
+- Class: **fact** when it is a genuine internal contradiction (two rules cannot both hold);
+  **preference** when it is merely "could be clearer."
+- Evidence: optional — name the two conflicting passages, or the ambiguity.
+- Routing: clarify the rule (or the shared standard, if the ambiguity lives there).
+
+### preference — a stylistic improvement
+A better way to phrase, name, or structure something, with no correctness stake.
+- Class: **preference** (always).
+- Evidence: optional, example only.
+- Routing: only after rule of three; below that it stays as warming evidence.
+
+## 3. Assigning the class
+
+Decision order:
+1. Did following the skill cause a bug? → `caused-bug`, **fact**.
+2. Is the skill's statement objectively false (wrong path/method/command, or self-contradiction)? →
+   `divergence` or `friction`, **fact**.
+3. Is a real, agreed pattern simply missing? → `gap`, **fact**.
+4. Otherwise it is a judgment call about what the standard *should* be → **preference** (`gap`,
+   `friction`, or `preference` signal as fits).
+
+Record the reasoning in `rationale` — it is decisive when PROMOTE adjudicates an edge call.
+
+## 4. Routing each signal at promote
+
+| Signal | Default target | Edit shape |
+|--------|----------------|-----------|
+| divergence | the target skill (or the shared standard if the wrong fact lives there) | correct the statement |
+| gap | the target skill's matching section, or a new section if `unmapped` | add/extend a rule |
+| caused-bug | the target skill | qualify the rule + add a guardrail note |
+| friction | the target skill, or the shared standard if the ambiguity is shared | clarify / reconcile |
+| preference | the target skill | adjust phrasing/structure, additively |
+
+A correction whose true home is a `solidstats-shared-*-standards` skill (because the wrong/ambiguous
+rule is *shared*, not stack-specific) routes there, not to the per-stack skill — the same delegation
+the skills already use. State the routing in one line and let the user redirect.

.agents/skills/solidstats-process-skill-feedback/references/signal-taxonomy.md

@@ -0,0 +1,68 @@
+# Correction entry template
+
+Append one block per correction to `<target-skill>/corrections-log.md` (in this skills repo). Heading
+for human scanning, YAML for machine parsing. Field meanings: `references/journal-schema.md`.
+
+```markdown
+### <id> · <signal> · <class> · <section>
+
+```yaml
+id: SC-<YYYY-MM-DD>-<4hex>
+date: <YYYY-MM-DD>
+target_skill: <solidstats-skill-name>
+repo: <server-2 | replays-fetcher | replay-parser-2 | web | n-a>
+source: <agent-discovered | human-edit | free-form-prose>
+signal: <divergence | gap | caused-bug | friction | preference>
+class: <fact | preference>
+generalized: <true | false>
+section: <"§X" or "unmapped">
+topic: <short-tag>
+dev_change: >
+  <what the skill says vs. what is true; for divergence carry the true fact>
+code:
+  file: <"path" or null>
+  line: <N or null>
+  source: <agent-snippet | head-besteffort | none>
+  status: <negative-example | positive-example | needs-code-context | n-a>
+  snippet: |
+    <the few relevant lines, or omit>
+rationale: >
+  <the "why" and the class reasoning (why fact vs preference)>
+status: open
+signature: "<signal>|<section>|<canonical-description>"
+```
+```
+
+## A filled example
+
+```markdown
+### SC-2026-06-22-7c1d · caused-bug · fact · §AA
+
+```yaml
+id: SC-2026-06-22-7c1d
+date: 2026-06-22
+target_skill: solidstats-shared-backend-ts-standards
+repo: server-2
+source: agent-discovered
+signal: caused-bug
+class: fact
+generalized: false
+section: "§AA"
+topic: observability
+dev_change: >
+  §AA's logging example logs the full request object, which includes the auth header; following it
+  leaked a bearer token into the logs. The rule should mandate redaction of the auth header.
+code:
+  file: "src/plugins/logging.ts"
+  line: 42
+  source: agent-snippet
+  status: negative-example
+  snippet: |
+    req.log.info({ req }, 'incoming request')
+rationale: >
+  Following the rule as written produces a security defect — fact, fixable at one occurrence. Add a
+  guardrail rather than deleting the logging guidance.
+status: open
+signature: "caused-bug|§AA|request logging leaks auth header"
+```
+```

.agents/skills/solidstats-process-skill-feedback/templates/correction-entry.md

@@ -0,0 +1,67 @@
+# CAPTURE — turn one divergence into a journal entry
+
+Run this per discovery, the moment a `solidstats-*` skill is shown wrong/incomplete/harmful — or when
+`capture-session-lessons` (or a proactive offer from the active skill, SKILL.md §E) routes a lesson
+here. Goal: classify it, bind the offending code, normalize, append to the journal in **this skills
+repo**, emit a regression case when code is bound, and stage it for commit. It never edits a target
+skill — that is PROMOTE's job.
+
+## Required reading
+- `references/signal-taxonomy.md` — the five signals and the fact/preference class rules
+- `references/journal-schema.md` — the entry schema and signature
+- `templates/correction-entry.md` — the block to append
+
+## Steps
+
+0. **Resolve the canonical skills checkout** (SKILL.md §H). The journal must land in the real
+   `solid-stats/skills` repo, NOT the vendored `.agents/skills/**` copy you may be running from in a
+   consuming repo (it is overwritten on the next sync). Resolve: cwd/ancestor whose remote is
+   `solid-stats/skills` → else a local clone (`../skills` or under `~/Projects/**`, remote confirmed)
+   → else stop and ask. All journal paths below are relative to that checkout.
+
+1. **Confirm scope and resolve the target skill** (SKILL.md §C, §D). First apply the boundary test:
+   *would fixing this mean editing a `solidstats-*` SKILL.md or its references?* If no — it is a
+   product/code fact, not a skill divergence; stop and route it to memory/MemPalace instead. If yes,
+   resolve which skill: infer from the cited section/skill name; if uncertain, ask the user to pick
+   from the in-scope candidates. A misrouted correction pollutes the wrong skill's journal. Read that
+   skill's section list so `section`/`topic` use its vocabulary.
+
+2. **Classify.** Set `signal` (divergence / gap / caused-bug / friction / preference) and `class`
+   (fact / preference) per the taxonomy decision order. The class is the load-bearing field — get it
+   right, because it decides whether one occurrence can promote. Record the class reasoning in
+   `rationale`.
+
+3. **Bind the evidence** (SKILL.md §G):
+   - For a **divergence**, the evidence is the *true fact* (the real path/method) — put it in
+     `dev_change`; add a `file:line` in the consuming repo if one proves it.
+   - For a **gap** / **caused-bug**, bind the code: prefer the exact snippet the agent was looking at
+     (`code.source: agent-snippet`); else best-effort from local `HEAD` by `file:line`, honoring the
+     HEAD caveat (an already-fixed snippet is a `positive-example`). For `caused-bug`, also capture the
+     bug (symptom or failing test) in `dev_change`.
+   - Unbindable and not a principle → `needs-code-context`; capture it but exclude from promotion
+     until resolved.
+
+4. **Author the signature** (`signal|section|canonical-description`), wording the description so a
+   future near-duplicate collapses onto it (journal-schema §3).
+
+5. **Append the entry** to `<target-skill>/corrections-log.md` using the template. Create the file on
+   first use for that target. Never rewrite existing entries — append only; the log is an audit trail.
+
+6. **Emit a regression case** (optional, recommended for conventions/code-review targets). For an
+   entry with bound code, append one JSONL line to `<target-skill>/regression-evals.jsonl`
+   (journal-schema §4). Skip `needs-code-context` entries.
+
+7. **Stage for commit.** `git add` the journal files (`corrections-log.md`, and
+   `regression-evals.jsonl` if written). **Do not commit or push** unless the user asks — AGENTS.md
+   forbids autonomous commits, and this repo is shared truth. Tell the user the entry is staged.
+
+8. **Print the soft nudge.** For this target, count `open` entries, `fact` entries ready to promote
+   (each promotable at one), and preference clusters at/over three. Report, e.g.:
+   `📊 solidstats-server-ts-conventions: 4 open · 1 fact ready · 0 preference-clusters ≥3.`
+   Information, not an instruction — the user decides when to run PROMOTE.
+
+## Output
+
+A short summary: the target skill, the signal+class captured, whether code was bound (and as a
+positive or negative example), any `needs-code-context` flag, and the nudge line. Do not propose a
+skill edit here.