@olegkoval/agent-skills 1.59.2 → 1.60.0

package/adapters/claude/olko-reflection/skills/self-critique/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: self-critique
-description: Adversarially critique your own last substantial answer before the user has to. Spawn a critic agent that verifies every claim against live sources, checks similar and related issues, finds patterns, and addresses comments directly to you. Loop (revise, re-score) until satisfied, report where you were wrong, iterations-to-satisfy, the numeric improvement and a final score, then convert what the critic caught into a durable rule so the next session does not repeat it. Use when the user asks you to criticize, challenge, stress-test, or red-team your own answer, or accepts a "critical-thinking review" offer.
+description: Adversarially critique your own last answer: a blind critic agent re-derives and verifies every claim against live sources, the score is computed from a labelled claim ledger, you revise under a ratchet, restate the corrected answer, and turn each caught error into a durable rule with a fire counter.
 license: MIT
 compatibility: Codex, Claude Code, Cursor, and other Agent Skills compatible tools.
 metadata:
@@ -42,40 +42,102 @@ durable rule has bought every answer after it.
 Do not use for trivial one-shot replies or simple chat. The overhead only pays off on load-bearing
 answers.
 
+**Standalone Cursor installation.** Use the generated Cursor adapter or the full skill package,
+including its `scripts/` directory. Copying only `SKILL.md` is insufficient for this workflow,
+which calls the bundled scripts.
+
 ## Procedure
 
-1. **Snapshot the target.** Capture your last substantial answer verbatim, plus the concrete claims
-   it makes and the source each claim rests on. This is `v1`.
+1. **Snapshot the target.** Capture your last substantial answer verbatim and the original task
+   text. This is `v1`.
 
-   Write the claim list before you re-read the answer's prose, and put a real receipt against each
+   Write your claim list before you re-read the answer's prose, and put a real receipt against each
    claim: a quoted field, a `file:line` whose body you actually opened, a command and its output.
-   A claim you cannot receipt at snapshot time is already a finding - mark it `unverified` yourself
+   A claim you cannot receipt at snapshot time is already a finding - mark it `unverifiable` yourself
    rather than waiting for the critic to find it. Grep output, a file name, a path, an endpoint
    string, or the behaviour of a sibling module are not receipts for what code does; they prove
    those things exist, not what they do.
 
-2. **Spawn the critic.** Launch one independent agent with live-source access (issue tracker, code
-   host, error monitor, the repo). Use the prompt template below. The critic must return: `score`
-   (0-100), `verdict` (AGREE / AGREE-WITH-CAVEATS / DISAGREE), `where_wrong` (list), `missed`
-   (related issues or patterns you failed to surface), `unverifiable` (claims it could not confirm),
-   `fixes` (ranked, actionable), and `shapes` (the reusable class of reasoning behind each
-   `where_wrong` item, which Step 5 turns into the rule).
-
-3. **Decide and loop.** Stop if `score >= 90` OR no actionable `fixes` remain. Otherwise revise the
-   answer using the fixes to produce `v2`, then re-spawn the critic to score `v2`. Repeat.
+   Save the list to `.self-critique/author-claims.json` as an array of
+   `{ id, text, load_bearing, receipt }`. Do NOT show it to the critic in round one.
+
+   **Replay pass.** Before spawning the critic, check the answer against every stored rule. Resolve
+   the memory dir as the auto-memory dir for the current project, else the repo's `.claude/memory`;
+   if neither exists, skip replay, evidence-check, and prune with a one-line note. Run
+   `node <skill>/scripts/rule-store.mjs checklist --dir <memory dir>`, then open each listed rule's
+   memory file and read its body before testing the answer against it. The checklist's names and
+   descriptions alone are insufficient. Tag each hit `(recurring)` in the report and record it with
+   `node <skill>/scripts/rule-store.mjs fire <name> --dir <memory dir> --date <today>`.
+   Fire counters and pruning apply only to rules in this memory directory. Rules routed to
+   `CLAUDE.md`, `AGENTS.md`, or the shared store are neither counted nor pruned.
+
+2. **Spawn the critic (blind).** Launch one independent agent with live-source access (issue tracker,
+   code host, error monitor, the repo). Round one input is the original task text and the answer
+   verbatim, nothing else: the critic extracts the claims itself and never sees your list or sources.
+   Use the prompt template below. The critic must return one fenced JSON block with `claims` (its own
+   list, each `{ text, load_bearing, status, checked_by, receipt }`), `missed`, `where_wrong`,
+   `shapes` and `verdict` (AGREE / AGREE-WITH-CAVEATS / DISAGREE). There is no `score` field: the
+   score is computed in Step 2b.
+
+2b. **Merge into the ledger.** Match the critic's claims to yours by meaning and set `origin` on
+   each: `both`, `author` (only you found it), `critic` (only the critic found it). Every critic
+   finding with `checked_by: inferred` must be re-verified by you before it may become `verified`
+   or `refuted`; if you cannot verify it, it stays `inferred`. Both statuses require
+   `checked_by: command` or `checked_by: read` and a non-empty receipt; validation rejects inferred evidence or a missing
+   receipt. Save `.self-critique/ledger-v1.json`, then run
+   `node <skill>/scripts/claim-ledger.mjs score .self-critique/ledger-v1.json` and
+   `node <skill>/scripts/claim-ledger.mjs summary .self-critique/ledger-v1.json` (an invalid ledger
+   exits 2 and prints the errors as JSON).
+   Claims found by only one side are reported under their own heading, "Asymmetric claims".
+
+   Ledger shape (`version` is always `1`):
+
+   ```json
+   { "version": 1,
+     "claims": [{ "id": "c1", "text": "...", "load_bearing": true, "origin": "both",
+                  "status": "verified", "checked_by": "command", "receipt": "quoted output" }],
+     "missed": [{ "id": "m1", "text": "...", "load_bearing": false, "checked_by": "read" }] }
+   ```
+
+   - `origin`: `author` | `critic` | `both`
+   - `status`: `verified` | `refuted` | `unverifiable` | `inferred`
+   - `checked_by`: `command` (run, output quoted) | `read` (file or record opened, quoted) |
+     `inferred` (reasoning only). Required on `missed` items too; an `inferred` missed item is not
+     penalised. A `verified` or `refuted` claim may not use inferred evidence and requires a
+     non-empty receipt.
+
+3. **Decide and loop.** Accept a score of at least 90 only after all fixable findings are resolved
+   or explicitly qualified in the answer and report; otherwise continue the critique loop. Stop
+   when that condition holds, OR no ledger item is left that a revision could fix, OR 3 rounds have run.
+   Otherwise revise the answer to produce `v2`, write `ledger-v2.json`, and run
+   `node <skill>/scripts/claim-ledger.mjs ratchet .self-critique/ledger-v1.json .self-critique/ledger-v2.json`
+   on the previous and new ledger: a lower re-score discards the revision, and you keep the winner. Round
+   two and later hand the critic your receipts for the still-open claims (it is no longer blind).
    **Hard cap: 3 critic rounds.** (A known ceiling: raise it only if a round is still finding real,
    fixable defects.)
 
-4. **Report, always, even after a single round:**
+   **Cost.** The critic runs on a mid-tier model (Sonnet class) by default. Escalate one tier only
+   when a mid-tier round found nothing and the answer is load-bearing. When the budget is tight,
+   verify load-bearing claims first.
+
+4. **Report, always, even after a single round.** In this order:
+   - **Corrected answer (`v_final`)** - restated in full, not as a diff, so the user can act on it
+     without reading anything else. After a single round with no revision, restate `v1` unchanged.
+   - **Claim ledger** - run `node <skill>/scripts/claim-ledger.mjs summary <ledger for v_final>`
+     and `node <skill>/scripts/claim-ledger.mjs score <ledger for v_final>` using the ledger for
+     whichever version the ratchet accepted (for example, `.self-critique/ledger-v2.json`). Report
+     that table and its computed score.
    - **Where you were wrong** - consolidated, each item with the receipt the critic cited.
-   - **Iterations to satisfy** - how many critic rounds it took to reach the stop condition (1 means
-     it was solid on the first pass).
-   - **Improvement in numbers** - the score trajectory, for example `72 -> 88 -> 94 (+22 pts, +31%)`.
-     If only one round ran, state `no revision needed`.
-   - **Final score** - the critic's last score and verdict.
+   - **Asymmetric claims** - claims only you found, and claims only the critic found.
+   - **Recurring rules fired** - each stored rule the replay pass hit, with its new `fires` count.
+   - **Iterations to satisfy** - how many critic rounds it took (1 means it was solid first pass).
+   - **Score trajectory** - for example `72 -> 88 -> 94 (+22 pts)`, all computed scores. If only one
+     round ran, state `no revision needed`.
    - **Unverifiable** - anything you should not present as fact.
-   - **Declined fixes** - any ranked fix you chose not to take, and the reason. Silently dropping a
-     fix looks identical to missing it.
+   - **Declined findings** - ledger items you chose not to fix, with the reason. Silently dropping
+     one looks identical to missing it.
+   - **Rules written** - where each rule went and what it says (see Step 5).
+   - **Rules proposed for deletion** - the candidates from the prune pass, or `none`.
 
 5. **Convert the outcome into a durable rule.** See below. Skipping this step is what makes the
    same critique necessary again next week.
@@ -126,31 +188,50 @@ Before writing to shared persistence, redact the incident evidence, including wh
 `context-repo` or `shared-knowledge-artifact`, while still including the incident and its dated
 receipt. This redaction requirement does not apply to local agent memory or repository-rule writes.
 
-**Dedupe before writing.** Read the store first. If a rule of the same shape exists, sharpen it and
-add this incident as further evidence rather than creating a second entry. Link related rules
-instead of restating them.
+**Dedupe before writing.** Read the store first. If a rule of the same shape exists, add one dated
+evidence line to it instead of creating a second entry, with at most three evidence lines per rule.
+A fourth incident means the rule named the incident, not the shape: rewrite the rule text and keep
+the three most recent evidence lines. Link related rules instead of restating them. Only when the
+memory directory resolved in Step 1 exists, run
+`node <skill>/scripts/rule-store.mjs evidence-check --dir <memory dir>` before writing and report
+any rule it flags. Skip this command when neither supported memory directory exists.
+
+**Memory rule identity and counters.** Mark each rule stored by this workflow with
+`rule_store: self-critique` under `metadata:` in its memory file's frontmatter. Mark an existing
+rule only after reading it and confirming it belongs to this workflow. Only marked rules are
+pruning candidates; unrelated project and user memories are excluded. A memory rule's `fires` and
+`last_fired` live under `metadata:` and are written only by `fire`. Rules routed to `CLAUDE.md`,
+`AGENTS.md`, or the shared store are neither counted nor pruned.
+
+**Prune pass.** At the end of this step, only when a valid memory directory is available, run
+`node <skill>/scripts/rule-store.mjs prune --dir <memory dir> --idle-days 60`. List the candidates
+in the report under "Rules proposed for deletion". Skip this command when neither supported memory
+directory exists. Never delete a rule without the user's reply.
 
 **Then close the loop.** State in your report where the rule was written and what it says, so the
 user can veto it. A rule the user has not seen is a rule they cannot correct.
 
 ## Critic prompt template
 
-Pass this to the critic agent, filling in the two placeholders. It is deliberately adversarial:
+Pass this to the critic agent, filling in the two placeholders (`{{TASK}}`, `{{ANSWER}}`). It is deliberately adversarial:
 the default stance is that the answer is wrong until a live source proves otherwise.
 
 > You are an adversarial reviewer. Your job is to verify and, where possible, **refute** the answer
 > below. Default to skepticism: assume a claim is wrong until a live source proves it. Address every
 > comment **directly to the author** ("You claimed X; the source says Y").
 >
+> **The task the author was given (verbatim):**
+> {{TASK}}
+>
 > **The answer under review (verbatim):**
 > {{ANSWER}}
 >
-> **Its claims and the source each rests on:**
-> {{CLAIMS_AND_SOURCES}}
+> You are not given the author's claims or sources. Extract the claims yourself.
 >
 > **Do this:**
-> 1. Re-verify every claim against the **live** source (issue tracker / code host / error monitor /
->    the repo) - never trust the answer's own summary. Quote the field, line, PR body, or issue you
+> 1. List every claim the answer makes, marking each `load_bearing` (the user would act on it).
+>    Re-verify each against the **live** source (issue tracker / code host / error monitor / the
+>    repo) - never trust the answer's own summary. Quote the field, line, PR body, or issue you
 >    checked.
 > 2. **Check similar and related issues, and find patterns.** Is this part of a cluster? Is there a
 >    closer sibling, parent epic, or duplicate the answer should have surfaced but did not? Name it
@@ -160,19 +241,62 @@ the default stance is that the answer is wrong until a live source proves otherw
 >    a proven root cause?
 > 4. List exactly **where the author was wrong or imprecise**, and what they **missed**.
 > 5. Flag any claim you **could not verify** so it is not presented as fact.
+> 6. Label every finding with `checked_by`: `command` (you ran it and quote the output), `read` (you
+>    opened the file or record and quote it), `inferred` (reasoning only).
 >
-> **Output, terse, with a receipt for every line:**
-> - `verdict`: AGREE | AGREE-WITH-CAVEATS | DISAGREE
-> - `score`: 0-100 (rubric: 100 = every claim verified, nothing missed, confidence correctly
->   calibrated; subtract for each unverified claim, each missed sibling or pattern, and each
->   over- or under-statement)
-> - `where_wrong`: bullet list, each with its source receipt
-> - `missed`: related issues or patterns the author failed to surface, with IDs
-> - `unverifiable`: claims that need a source you do not have
-> - `fixes`: ranked, actionable - what to change to raise the score
+> **Output, terse, one fenced JSON block, a receipt for every item:**
+> - `claims`: your own list, each `{ text, load_bearing, status, checked_by, receipt }` with `status`
+>   one of `verified` | `refuted` | `unverifiable` | `inferred`
+> - `missed`: related issues or patterns the author failed to surface, each
+>   `{ text, load_bearing, checked_by, receipt }`, with IDs
+> - `where_wrong`: bullet list, each with its source receipt and `checked_by`
 > - `shapes`: for each item in `where_wrong`, the class of reasoning that produced it, stated so it
 >   would apply to a different task ("a conclusion drawn from evidence that does not cover the
 >   claim"), not the incident itself. Say `one-off` when the error has no reusable shape.
+> - `verdict`: AGREE | AGREE-WITH-CAVEATS | DISAGREE
+>
+> Do not output a score. It is computed from your claims.
+
+### Score anchors
+
+The score is `100` minus penalties, floored at 0. Calibrate against these three ledgers (all claims
+`origin: both`; `node <skill>/scripts/claim-ledger.mjs anchors` prints them as JSON).
+
+**Strong, score 95**
+
+| id | load_bearing | status | checked_by |
+| --- | --- | --- | --- |
+| a1 | no | inferred | inferred |
+
+**Middling, score 72**
+
+| id | load_bearing | status | checked_by |
+| --- | --- | --- | --- |
+| b1 | no | refuted | read |
+| b2 | no | refuted | read |
+| b3 | no | unverifiable | read |
+| b4 | no | unverifiable | read |
+
+**Weak, score 40**
+
+| id | load_bearing | status | checked_by |
+| --- | --- | --- | --- |
+| c1 | yes | refuted | read |
+| c2 | yes | refuted | read |
+| c3 | yes | unverifiable | read |
+
+Penalties:
+
+| Finding | Points off |
+| --- | --- |
+| refuted, load-bearing | 25 |
+| refuted | 10 |
+| unverifiable, load-bearing | 10 |
+| unverifiable | 4 |
+| inferred, accepted | 5 |
+| missed, load-bearing | 15 |
+| missed | 5 |
+| verified but found only by the critic | 5 |
 
 ## Optional: auto-offer via a Claude Code Stop hook
 
@@ -218,10 +342,10 @@ message.
   `iterations: 1, no revision needed` and the single score rather than forcing a revision.
 - Diversity beats redundancy: if a claim can fail in more than one way, give the critic distinct
   lenses (correctness, completeness, does-it-reproduce) instead of repeating the same check.
-- The critic verifies against live sources; it does not rewrite the answer. You revise; it re-scores.
-- Re-score by messaging the same critic rather than spawning a fresh one, and hand it the receipts
-  for whatever it could not verify in the earlier round, so round two spends its budget on the
-  claims still standing instead of re-deriving the ones already settled.
+- The critic verifies against live sources; it does not rewrite the answer or score it. You revise;
+  the score is recomputed from the ledger.
+- In round two, hand the critic your receipts for the claims still open, so it spends its budget on
+  the claims still standing instead of re-deriving the ones already settled.
 - A critic finding you disagree with is worth one challenge. Put the reasoning to it and let it rule;
   if it concedes, that is a real answer for the report, and the reasoning is what the user needs to
   see either way.

package/adapters/claude/olko-reflection/skills/self-critique/scripts/claim-ledger.mjs

@@ -0,0 +1,159 @@
+import { readFileSync } from 'node:fs'
+import { pathToFileURL } from 'node:url'
+
+export const PENALTIES = {
+  refuted_load_bearing: 25,
+  refuted: 10,
+  unverifiable_load_bearing: 10,
+  unverifiable: 4,
+  inferred_accepted: 5,
+  missed_load_bearing: 15,
+  missed: 5,
+  only_critic_found: 5,
+}
+
+const ORIGINS = ['author', 'critic', 'both']
+const STATUSES = ['verified', 'refuted', 'unverifiable', 'inferred']
+const CHECKED_BY = ['command', 'read', 'inferred']
+
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)
+const isText = (v) => typeof v === 'string' && v.length > 0
+
+const enumError = (path, field, value, allowed) => {
+  if (value === undefined) return [`${path}.${field} missing`]
+  return allowed.includes(value) ? [] : [`${path}.${field} invalid: ${value}`]
+}
+
+const claimErrors = (c, i) => {
+  const path = `claims[${i}]`
+  if (!isRecord(c)) return [`${path} invalid: not an object`]
+  return [
+    ...(isText(c.id) ? [] : [`${path}.id missing`]),
+    ...(isText(c.text) ? [] : [`${path}.text missing`]),
+    ...(typeof c.load_bearing === 'boolean' ? [] : [`${path}.load_bearing missing`]),
+    ...enumError(path, 'origin', c.origin, ORIGINS),
+    ...enumError(path, 'status', c.status, STATUSES),
+    ...enumError(path, 'checked_by', c.checked_by, CHECKED_BY),
+    ...(['verified', 'refuted'].includes(c.status) && c.checked_by === 'inferred'
+      ? [`${path}.checked_by: verified and refuted claims must be checked by command or read`]
+      : []),
+    ...(['verified', 'refuted'].includes(c.status) && !(typeof c.receipt === 'string' && c.receipt.trim().length > 0)
+      ? [`${path}.receipt: verified and refuted claims require a non-empty receipt`]
+      : []),
+  ]
+}
+
+const missedErrors = (m, i) => {
+  const path = `missed[${i}]`
+  if (!isRecord(m)) return [`${path} invalid: not an object`]
+  return [
+    ...(isText(m.id) ? [] : [`${path}.id missing`]),
+    ...(isText(m.text) ? [] : [`${path}.text missing`]),
+    ...(typeof m.load_bearing === 'boolean' ? [] : [`${path}.load_bearing missing`]),
+    ...enumError(path, 'checked_by', m.checked_by, CHECKED_BY),
+  ]
+}
+
+export const validateLedger = (ledger) => {
+  if (!isRecord(ledger)) return ['ledger invalid: not an object']
+  if (!Array.isArray(ledger.claims)) return ['claims missing']
+  if (!Array.isArray(ledger.missed)) return ['missed missing']
+  return [...ledger.claims.flatMap(claimErrors), ...ledger.missed.flatMap(missedErrors)]
+}
+
+const claimPenalties = (c) => {
+  const lb = c.load_bearing
+  const byStatus = {
+    refuted: [lb ? 'refuted_load_bearing' : 'refuted'],
+    unverifiable: [lb ? 'unverifiable_load_bearing' : 'unverifiable'],
+    inferred: ['inferred_accepted'],
+    verified: c.origin === 'critic' ? ['only_critic_found'] : [],
+  }
+  return byStatus[c.status]
+}
+
+const missedPenalty = (m) => (m.load_bearing ? 'missed_load_bearing' : 'missed')
+
+const tally = (keys) =>
+  keys.reduce((acc, k) => ({ ...acc, [k]: (acc[k] ?? 0) + PENALTIES[k] }), {})
+
+export const scoreLedger = (ledger) => {
+  const breakdown = tally([...ledger.claims.flatMap(claimPenalties), ...ledger.missed.filter((m) => m.checked_by !== 'inferred').map(missedPenalty)])
+  const total = Object.values(breakdown).reduce((a, b) => a + b, 0)
+  return { score: Math.max(0, 100 - total), breakdown }
+}
+
+export const ratchet = (prev, next) => {
+  const p = scoreLedger(prev).score
+  const n = scoreLedger(next).score
+  return p > n ? { winner: 'prev', score: p } : { winner: 'next', score: n }
+}
+
+const mk = (id, lb, status) => ({
+  id,
+  text: `claim ${id}`,
+  load_bearing: lb,
+  origin: 'both',
+  status,
+  checked_by: status === 'inferred' ? 'inferred' : 'read',
+  receipt: 'anchor',
+})
+
+// 95 = 5 (one inferred); 72 = 10+10+4+4; 40 = 25+25+10
+const ANCHOR_LEDGERS = [
+  { label: 'strong', claims: [mk('a1', false, 'inferred')] },
+  { label: 'middling', claims: [mk('b1', false, 'refuted'), mk('b2', false, 'refuted'), mk('b3', false, 'unverifiable'), mk('b4', false, 'unverifiable')] },
+  { label: 'weak', claims: [mk('c1', true, 'refuted'), mk('c2', true, 'refuted'), mk('c3', true, 'unverifiable')] },
+]
+
+export const anchors = () =>
+  ANCHOR_LEDGERS.map(({ label, claims }) => {
+    const ledger = { version: 1, claims, missed: [] }
+    return { label, ledger, score: scoreLedger(ledger).score }
+  })
+
+const cell = (s) => String(s ?? '').replaceAll('|', '\\|').replaceAll('\n', ' ')
+
+const claimRow = (c) =>
+  `| ${[c.id, c.text, c.origin, c.status, c.checked_by, c.receipt].map(cell).join(' | ')} |`
+
+export const summaryMarkdown = (ledger) =>
+  [
+    '| id | claim | origin | status | checked_by | receipt |',
+    '| --- | --- | --- | --- | --- | --- |',
+    ...ledger.claims.map(claimRow),
+  ].join('\n')
+
+const fail = (message) => {
+  process.stderr.write(`${JSON.stringify({ error: message })}\n`)
+  process.exit(2)
+}
+
+const loadLedger = (path) => {
+  let parsed
+  try {
+    parsed = JSON.parse(readFileSync(path, 'utf8'))
+  } catch (e) {
+    return fail(`cannot read ${path}: ${e.message}`)
+  }
+  const errors = validateLedger(parsed)
+  if (errors.length > 0) return fail(errors.join('; '))
+  return parsed
+}
+
+const COMMANDS = {
+  score: ([a]) => scoreLedger(loadLedger(a)),
+  ratchet: ([a, b]) => ratchet(loadLedger(a), loadLedger(b)),
+  anchors: () => anchors(),
+  summary: ([a]) => summaryMarkdown(loadLedger(a)),
+}
+
+const main = (argv) => {
+  const [cmd, ...args] = argv
+  const run = COMMANDS[cmd]
+  if (!run) return fail(`unknown command: ${cmd}`)
+  const out = run(args)
+  process.stdout.write(typeof out === 'string' ? `${out}\n` : `${JSON.stringify(out, null, 2)}\n`)
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) main(process.argv.slice(2))

package/adapters/claude/olko-reflection/skills/self-critique/scripts/rule-store.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// Rule store over a directory of Claude Code memory files (Markdown + frontmatter).
+// Frontmatter is parsed line by line so unrelated lines survive a rewrite byte for byte.
+import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const FENCE = '---';
+const EVIDENCE_LINE = /^\s*-\s.*\b20\d\d-\d\d-\d\d\b/;
+const DAY_MS = 86_400_000;
+
+const topLevelKey = (line) => /^([A-Za-z_][\w-]*):(?: (.*))?$/.exec(line);
+const metaEntry = (line) => /^ {2}([A-Za-z_][\w-]*):(?: (.*))?$/.exec(line);
+
+function splitFrontmatter(text) {
+  if (!text.startsWith(`${FENCE}\n`)) return null;
+  const rest = text.slice(FENCE.length + 1);
+  const closeAt = rest.startsWith(`${FENCE}\n`) || rest === FENCE
+    ? 0
+    : rest.indexOf(`\n${FENCE}\n`) === -1
+      ? (rest.endsWith(`\n${FENCE}`) ? rest.length - FENCE.length - 1 : -1)
+      : rest.indexOf(`\n${FENCE}\n`) + 1;
+  if (closeAt === -1) return null;
+  const front = rest.slice(0, closeAt);
+  const body = rest.slice(closeAt + FENCE.length + 1);
+  return { frontLines: front === '' ? [] : front.replace(/\n$/, '').split('\n'), body };
+}
+
+// top keeps every frontmatter line in order; metadata children are lifted into `metadata`.
+function readTop(frontLines) {
+  const top = [];
+  const metadata = {};
+  let inMeta = false;
+  for (const line of frontLines) {
+    const meta = inMeta ? metaEntry(line) : null;
+    if (meta) {
+      metadata[meta[1]] = meta[2] ?? '';
+      continue;
+    }
+    const key = topLevelKey(line);
+    inMeta = key?.[1] === 'metadata';
+    top.push({ key: key?.[1] ?? null, line });
+  }
+  return { top, metadata };
+}
+
+export function parseRule(text) {
+  const parts = splitFrontmatter(text);
+  if (!parts) return null;
+  const { top, metadata } = readTop(parts.frontLines);
+  const valueOf = (key) => {
+    const entry = top.find((t) => t.key === key);
+    return entry ? (topLevelKey(entry.line)?.[2] ?? '') : '';
+  };
+  return { name: valueOf('name'), description: valueOf('description'), metadata, body: parts.body, top };
+}
+
+function topLines(rule) {
+  const hasMeta = rule.top.some((t) => t.key === 'metadata');
+  const top = hasMeta || Object.keys(rule.metadata).length === 0
+    ? rule.top
+    : [...rule.top, { key: 'metadata', line: 'metadata:' }];
+  return top.flatMap((t) =>
+    t.key === 'metadata'
+      ? [t.line, ...Object.entries(rule.metadata).map(([k, v]) => `  ${k}: ${v}`)]
+      : [t.line],
+  );
+}
+
+export function serializeRule(rule) {
+  const lines = topLines(rule);
+  return `${FENCE}\n${lines.length ? `${lines.join('\n')}\n` : ''}${FENCE}\n${rule.body}`;
+}
+
+function readRuleFiles(dir) {
+  return fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith('.md'))
+    .sort()
+    .flatMap((file) => {
+      const rule = parseRule(fs.readFileSync(path.join(dir, file), 'utf8'));
+      return rule && rule.name ? [{ file, rule }] : [];
+    });
+}
+
+export const listRules = (dir) => readRuleFiles(dir).map((e) => e.rule);
+
+export const checklistMarkdown = (dir) =>
+  listRules(dir).map((r) => `- [${r.name}]: ${r.description}\n`).join('');
+
+export function bumpFire(rule, isoDate) {
+  const fires = Number.parseInt(rule.metadata.fires ?? '0', 10) || 0;
+  return { ...rule, metadata: { ...rule.metadata, fires: String(fires + 1), last_fired: isoDate } };
+}
+
+export function fire(dir, name, isoDate) {
+  const entry = readRuleFiles(dir).find((e) => e.rule.name === name);
+  if (!entry) throw new Error(`rule not found: ${name}`);
+  const updated = bumpFire(entry.rule, isoDate);
+  const target = path.join(dir, entry.file);
+  const temporary = path.join(dir, `.${entry.file}.${randomUUID()}.tmp`);
+  try {
+    fs.writeFileSync(temporary, serializeRule(updated), { flag: 'wx', mode: fs.statSync(target).mode });
+    fs.renameSync(temporary, target);
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+  return updated;
+}
+
+const daysBetween = (fromIso, toIso) => (Date.parse(toIso) - Date.parse(fromIso)) / DAY_MS;
+
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}/;
+
+// age signal: frontmatter modified, else created, else file mtime
+function ageDate(rule, mtimeIso) {
+  const declared = [rule.metadata.modified, rule.metadata.created].find((v) => ISO_DAY.test(v ?? ''));
+  return declared ?? mtimeIso;
+}
+
+export function pruneReason(rule, { idleDays, today, mtimeIso }) {
+  if (rule.metadata.fires === undefined) {
+    return daysBetween(ageDate(rule, mtimeIso), today) > idleDays ? 'never-fired' : null;
+  }
+  const last = rule.metadata.last_fired;
+  return last && daysBetween(last, today) > idleDays ? 'idle' : null;
+}
+
+export function prune(dir, { idleDays, today }) {
+  return readRuleFiles(dir).flatMap(({ file, rule }) => {
+    if (rule.metadata.rule_store !== 'self-critique') return [];
+    const mtimeIso = fs.statSync(path.join(dir, file)).mtime.toISOString().slice(0, 10);
+    const reason = pruneReason(rule, { idleDays, today, mtimeIso });
+    return reason ? [{ name: rule.name, reason }] : [];
+  });
+}
+
+export const countEvidence = (body) => body.split('\n').filter((l) => EVIDENCE_LINE.test(l)).length;
+
+export function evidenceCheck(dir, { max }) {
+  return listRules(dir).flatMap((rule) => {
+    const count = countEvidence(rule.body);
+    return count > max ? [{ name: rule.name, count }] : [];
+  });
+}
+
+function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg.startsWith('--')) {
+      flags[arg.slice(2)] = rest[i + 1];
+      i += 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { command, flags, positional };
+}
+
+const todayIso = () => new Date().toISOString().slice(0, 10);
+
+function runCli(argv) {
+  const { command, flags, positional } = parseArgs(argv);
+  const dir = flags.dir;
+  if (!dir) throw new Error('--dir is required');
+  const date = flags.date ?? todayIso();
+  const commands = {
+    list: () => JSON.stringify(listRules(dir).map(({ top, ...rule }) => rule), null, 2),
+    checklist: () => checklistMarkdown(dir).trimEnd(),
+    fire: () => {
+      const { top, ...rule } = fire(dir, positional[0], date);
+      return JSON.stringify(rule, null, 2);
+    },
+    prune: () => JSON.stringify(prune(dir, { idleDays: Number(flags['idle-days'] ?? 60), today: date }), null, 2),
+    'evidence-check': () => JSON.stringify(evidenceCheck(dir, { max: 3 }), null, 2),
+  };
+  const run = commands[command];
+  if (!run) throw new Error(`usage: rule-store.mjs ${Object.keys(commands).join('|')} --dir <dir>`);
+  return run();
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  try {
+    console.log(runCli(process.argv.slice(2)));
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+}

package/adapters/codex/olko-product/README.md

@@ -4,6 +4,7 @@
 
 Use the canonical skills directly:
 
+- `plugins/olko-product/skills/ingest-publication-slice/SKILL.md`
 - `plugins/olko-product/skills/product-builder/SKILL.md`
 - `plugins/olko-product/skills/mvp-oneshot/SKILL.md`
 - `plugins/olko-product/skills/ux-ui-audit-loop/SKILL.md`