@olegkoval/agent-skills 1.59.2 → 1.60.0

package/adapters/grok/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/grok/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/hermes/olko-product/README.md

@@ -5,6 +5,7 @@
 Run `./scripts/install-hermes-symlinks.sh` from the repository root to link these skills
 into the active Hermes profile. The canonical packages are:
 
+- `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`

package/catalog/skills.json

@@ -514,6 +514,28 @@
       "name": "olko-product",
       "description": "Take a product idea to a shippable build: MVP passes, full-stack scaffolds, UX/UI quality loops, launch plans.",
       "skills": [
+        {
+          "name": "ingest-publication-slice",
+          "lookupName": "olko:ingest-publication-slice",
+          "path": "plugins/olko-product/skills/ingest-publication-slice",
+          "description": "Build and verify a small end-to-end publication path for validated ingested data, including atomic persistence, read fallback, and static artifact precedence.",
+          "tags": [
+            "ingest",
+            "publication",
+            "testing",
+            "workflow"
+          ],
+          "adapters": [
+            "claude",
+            "codex",
+            "cursor",
+            "copilot",
+            "grok",
+            "windsurf",
+            "kiro",
+            "hermes"
+          ]
+        },
         {
           "name": "product-builder",
           "lookupName": "olko:product-builder",
@@ -846,7 +868,7 @@
           "name": "self-critique",
           "lookupName": "olko:self-critique",
           "path": "plugins/olko-reflection/skills/self-critique",
-          "description": "Adversarially critique your own last answer: spawn a critic agent that verifies claims against live sources, finds the related issue or pattern you missed, then loop until satisfied and report where you were wrong, iterations-to-satisfy, the numeric improvement, and a final score.",
+          "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.",
           "tags": [
             "critical-thinking",
             "self-review",