honerlaw

@honerlaw source repo

25 skills
0 followers
13 hours ago last updated

▌
Init · honerlaw bundle
Scaffolds the `.minerva/` directory layout and agent-file Routing section — durable records, knowledge tracking, and project memory for agent work in a project. Idempotent — re-runs report per-piece status without rewriting anything in place, and it warns about legacy `.minerva/decisions/` layouts. Use when adopting minerva or setting up durable record/knowledge discipline for the first time in a project, or when the user invokes `minerva:init`.

0
installs
▌
Lint · honerlaw
Health-checks the `.minerva/knowledge/` wiki — runs the deterministic detector for mechanical defects (index drift, broken `## Related` links, missing reciprocals) and adds LLM-judged advisory findings (orphans, contradictions, stale/superseded claims), presenting everything in `minerva:review`'s finding format. Read-only — it reports; deterministic repairs are applied via `minerva:lint-fix`, judgment-call repairs by hand. Use when the knowledge-lint CI gate is failing, the user asks to health-check / audit the wiki, or wants to surface orphaned / contradictory / stale knowledge entries, or when they invoke `minerva:lint`.

0
installs
▌
Ship · honerlaw bundle
Ships the current work — commits outstanding changes to a branch, opens a pull request, watches CI without blocking (a tracked watcher that resumes when checks settle, backed by a long scheduled fallback), fixes CI failures, and enables auto-merge. Use when the user asks to ship, push, open a PR for, or merge the current work — closing the minerva lifecycle after `minerva:work` / `minerva:promote` / `minerva:review` — or when they invoke `minerva:ship`.

0
installs
▌
Work · honerlaw bundle
Implements a minerva work unit — reads the proposal and any replans, maintains a live scratchpad, auto-invokes the `minerva:replan` protocol when reality drifts in a load-bearing way, and checks proposal Open Questions on resume and Success criteria before signaling completion. Use when the user is ready to start coding on a proposed feature, wants to implement or resume a work unit ("pick up where we left off"), or invokes `minerva:work`.

0
installs
▌
Debug · honerlaw bundle
Investigate a bug end-to-end — gather evidence first, then diagnose root cause grounded in that evidence, and report with a mechanically-derived confidence score. Use this whenever the user reports breakage of any kind. Live-incident framing — "users are reporting", "X is broken in prod", "the cron didn't run", "500s", "timeout", "stuck", "hanging", "queue backed up", "deployment failed", "metrics dropped", or past-tense framing like "we had an outage" — all qualify. Dev-bug framing — "this test fails", "function returns wrong value", "unexpected error", "regression", "TypeError", "why is this failing" — also qualifies. Trigger this even when the user doesn't explicitly say "debug" or "triage" — any reported breakage qualifies. The skill is project-agnostic; it loads project-specific operational facts from `.minerva/reference/` at runtime and cross-references past learnings in `.minerva/knowledge/`.

0
installs
▌
Replan · honerlaw
Records a course-correction for the current minerva work unit — drafts Original plan / What changed / New plan, stress-tests it via `minerva:grill-plan`, then appends a dated divergence entry to `.minerva/work/<date-slug>/replan.md`. Use when work has diverged from the proposal in a load-bearing way — a core assumption was wrong, the approach is changing, or scope is shifting — or to amend an approved proposal before `minerva:work` starts (pre-work tweaks), or when the user invokes `minerva:replan`.

0
installs
▌
Review · honerlaw bundle
Reviews a changeset against both the minerva spec/knowledge lenses and code quality. With a work unit in context it runs a spec/knowledge audit alongside the code quality review, presenting both result sets before unified triage; if a GitHub PR exists for the branch it delegates code quality to `code-review:code-review`, otherwise it performs a check via a fresh-context subagent in the same finding format. Triage state persists to the scratchpad so re-runs pre-fill prior dispositions. Use when implementation on a work unit has just finished and the diff is unreviewed, when the user asks to review or audit a changeset or to verify shipped code matches what was designed, or when they invoke `minerva:review`.

0
installs
▌
Status · honerlaw bundle
Prints the current overall status of a project's minerva workstream as markdown tables — every unit's lifecycle stage, phase progress, branch/PR state and the next lifecycle step to run, plus knowledge-wiki health and the deferred backlog. Read-only; mutates nothing. Use when the user asks where things stand, what's in flight, what to do next, what still needs shipping or cleaning up, or for a status check / summary / dashboard / overview of the work; when an agent resumes a project and needs to orient before picking up work ("pick up where we left off", "what were we doing"); or when they invoke `minerva:status`.

0
installs
▌
Cleanup · honerlaw bundle
Removes `.minerva/worktrees/<date-slug>/` directories whose branches have been merged into the default branch, prunes the corresponding local branches, and reconciles the knowledge wiki on the default branch — cataloguing entries that add-only promotes left pending, writing their reciprocal links, and refreshing the overview — via a single auto-merging PR. Idempotent; never force-removes unmerged work, and never commits directly to the default branch. Use after a PR merges, when the user asks to remove merged worktrees, prune stale minerva branches, catalogue pending knowledge entries, or generally tidy up after shipped work, or when they invoke `minerva:cleanup`.

0
installs
▌
Explore · honerlaw
Use when the user wants to explore a fuzzy idea, think through a problem, or weigh directions BEFORE committing to a work unit — when it's not yet clear whether there's anything to build, or what. The minerva analog of brainstorming — a divergent, commitment-free dialogue that writes no file, allocates no work unit, and creates no branch/worktree. Asks questions one at a time and weighs multiple high-level directions; may legitimately end in "don't build this" or "reframe the problem". When a direction is chosen, hands off to `minerva:propose` to design it. Use `minerva:propose` directly instead when you already know what you want to build and are ready to commit to a proposal. In a minerva project (`.minerva/` present), use this instead of generic brainstorming skills — it is the minerva-native front-end that hands off to `minerva:propose`.

0
installs
▌
Migrate · honerlaw
Checks an existing `.minerva/knowledge/` folder against the current LLM-wiki structure — read-only; runs the deterministic `migration_status` shape signal (files that don't conform to the naming convention and are therefore invisible to the wiki tooling — a false clean — plus missing index.md / overview.md and entries with no `## Related` cross-refs) and emits a migration checklist naming the existing skills that close each gap. It never edits files; renames and cross-ref authoring are judgment calls done by hand. Use when old notes don't appear in the index or lint reports clean on a corpus that predates the wiki conventions, when the user asks to migrate / restructure / refactor a legacy knowledge folder or wants a migration check, or when they invoke `minerva:migrate`.

0
installs
▌
Promote · honerlaw bundle
Finalizes a minerva work unit's record — promotes durable knowledge to `.minerva/knowledge/`, rewrites `proposal.md` to match reality, and archives the scratchpad; forward-looking TODOs are filed as prioritized GitHub issues when the repo can host them and fall back to `followups.md` when it cannot, never silently discarded. Also captures a significant mid-work decision/bug/pattern immediately. Use when implementation is done and the record needs finalizing, when a review has completed and the scratchpad holds unpromoted notes, or when the user invokes `minerva:promote`. Idempotent.

0
installs
▌
Propose · honerlaw bundle
Starts a new minerva work unit — brainstorm-style intake with one-question-at-a-time clarification, 2-3 candidate approaches, a `minerva:grill-plan` stress-test before approval, then creates the unit's branch + worktree and writes the approved design to `.minerva/work/<date-slug>/proposal.md`, with a self-review and a post-write user gate. Use when the user wants to plan or design a new feature, refactor, or investigation in a minerva-tracked project, says things like "let's build X", "let's plan Y", or "start a new unit of work", when `minerva:explore` hands off a converged direction, or when the user invokes `minerva:propose`.

0
installs
▌
Humanizer · honerlaw
Remove signs of AI-generated writing from text. Use when editing or reviewing text to make it sound more natural and human-written. Based on Wikipedia's comprehensive "Signs of AI writing" guide. Detects and fixes patterns including: inflated symbolism, promotional language, superficial -ing analyses, vague attributions, em dash overuse, rule of three, AI vocabulary words, passive voice, negative parallelisms, and filler phrases.

0
installs
▌
Lint Fix · honerlaw
Applies the deterministically-repairable subset of `minerva:lint` findings — MUTATES the `.minerva/knowledge/` wiki behind a confirmation gate (stale catalog lines, wrong Type-section placement, missing reciprocal `## Related` links) via the tested `scripts/knowledge_fix.py`. Never touches entry bodies and never auto-fixes judgment calls (missing catalog summaries, broken links, contradictions/staleness) — those it surfaces to handle by hand. Use after a lint run when the user asks to apply the safe/reported fixes or auto-repair the wiki, or when they invoke `minerva:lint-fix`. The read-only companion is `minerva:lint`.

0
installs
▌
Grill Plan · honerlaw
Use when a plan has just been drafted in conversation and needs stress-testing before approval — invoked by `minerva:propose` after approach selection and by `minerva:replan` after the new-plan brainstorm, also usable standalone on any drafted plan. Interviews the user relentlessly about the drafted plan, one question at a time, with the LLM's recommended answer leading each question, until shared understanding is reached.

0
installs
▌
Synthesize · honerlaw
Refreshes the knowledge-wiki overview — first reports the deterministic un-synthesized-scope signal (entries the overview does not link, plus broken overview wikilinks) so the caller decides IF resynthesis is warranted; if so, drafts a theme-grouped `overview.md` (narratives + `[[YYYY-MM-DD-type-slug]]` wikilinks) and, behind a confirmation gate, writes it. Use after `minerva:promote` adds knowledge entries and `overview.md` hasn't been refreshed, when the overview is missing or has broken wikilinks, when the user wants a theme-grouped summary across `.minerva/knowledge/`, or when they invoke `minerva:synthesize`. The overview is advisory (never CI-gated); only the mechanical link-rot signal is deterministic.

0
installs
▌
Migrate Fix · honerlaw bundle
Renames legacy `NNN`-prefixed knowledge entries and work units to date ids (`YYYY-MM-DD-type-slug`) — MUTATES `.minerva/knowledge/` and `.minerva/work/` behind a confirmation gate, deriving each date from the git history of the path itself and retargeting every wikilink, supersession marker and `**Context**` path via the tested `scripts/knowledge_rename.py`. Refuses the whole batch before moving anything if two entries would land on one name. Never renames git branches, and never edits an entry's body `**Date**` field. Use when a corpus still carries `NNN-` filenames and the user asks to migrate to date ids, or when they invoke `minerva:migrate-fix`. The read-only companion that tells you whether a corpus needs this is `minerva:migrate`.

0
installs
▌
Round Table · honerlaw bundle
Dispatches a 3-agent Proponent/Skeptic/Arbiter panel of fresh-context subagents over a decision or drafted artifact, counts accept votes against a caller-specified quorum (default 2/3), runs at most one revision round, and escalates to the user when consensus fails twice. Use when another skill delegates a decision to the consensus-panel protocol, when the user asks to convene a round table / decision panel / multi-agent consensus on a decision or drafted artifact, or when they invoke `minerva:round-table`. Usable standalone for any decision.

0
installs
▌
Propose Ship · honerlaw bundle
Runs the full minerva lifecycle end-to-end in one command with the user in the loop — a human decision gate at each phase transition. Orchestrates propose - work - review - promote - ship - cleanup by delegating to each skill in sequence with no logic duplication, refuses to start if in-flight work exists for the same intent, advances out of the work phase only on explicit user signal, and waits for the PR to actually merge before invoking cleanup. Use when the user wants the whole lifecycle while staying in control — "propose and ship", "I want to approve each step" — or when they invoke `minerva:propose-ship`.

0
installs
▌
Using Minerva · honerlaw bundle
Use when starting work in a project that uses minerva (a `.minerva/` directory exists at the project root, or the user has invoked any `minerva:` skill in this session), or when the user describes starting / continuing / finishing a meaningful unit of work — features, refactors, investigations, spikes. Explains when to invoke each minerva skill and gives common scenarios. Skip for routine bugfixes, trivial edits, and one-shot Q&A.

0
installs
▌
Capture Session · honerlaw
Use when the user wants to analyze or record token/cost usage from a Claude Code session they just ran, in any repo. Finds the most recent transcript, runs the cost analyzer, and optionally records to the benchmark baseline.

0
installs
▌
Propose Ship Auto · honerlaw bundle
Runs the full minerva lifecycle end-to-end with no human gates — fully automated, for unattended runs ("do the whole thing without asking", "handle decisions yourself", "auto propose and ship"). Same lifecycle as `minerva:propose-ship` (propose - work - review - promote - ship - cleanup, where `minerva:cleanup` reconciles the knowledge wiki on the default branch), but replaces each human-facing decision with a 3-agent Proponent/Skeptic/Arbiter consensus panel (mechanics delegated to `minerva:round-table`). Human input is only a fallback when a panel can't agree after one revision round, and a fail-closed skip predicate lets genuinely small decisions run panel-free. Use for non-trivial changes the user wants shipped autonomously, or when they invoke `minerva:propose-ship-auto`.

0
installs
▌
Propose Ship Quick · honerlaw bundle
Runs the full minerva lifecycle end-to-end fast for a small, low-risk change — a small UI fix, a bug fix, a one-file tweak ("just ship this small fix", "quick propose and ship", "do the whole thing quickly"). Same lifecycle as `minerva:propose-ship-auto` (propose - work - review - promote - ship - cleanup) with no scheduled human gates, but the main model adjudicates every strategic/tactical decision directly — no panels. User input is an exceptional fail-closed fallback (real ambiguity, high blast radius, an unfamiliar public interface, a knowledge constraint). If the change proves larger than small, it escalates recommending `minerva:propose-ship-balanced` (one reviewer), `minerva:propose-ship-auto` (panels), or `minerva:propose-ship` (human gates). Use for small low-risk end-to-end changes, or when the user invokes `minerva:propose-ship-quick`.

0
installs
▌
Propose Ship Balanced · honerlaw bundle
Runs the full minerva lifecycle end-to-end for a MEDIUM change — bigger than a one-file tweak, not ambiguous or high-stakes enough for panels ("ship this with a second opinion", "sanity-check the approach", "one reviewer, not a committee", a multi-file refactor). The middle rung of the autonomous ladder — third of four overall — between `minerva:propose-ship-quick` (solo) and `minerva:propose-ship-auto` (panels) — the main model decides directly but dispatches a SINGLE fresh-context advisory reviewer at the high-signal gates (scope, approach, whole-proposal, completion, plus the rare never-elide gates) and arbitrates the critique inline — no panel; a folded critique gets one fold-audit re-check, never a third dispatch. User input is only a fail-closed fallback; if the change proves larger it escalates recommending `minerva:propose-ship-auto` or `minerva:propose-ship`. Use for autonomous medium-sized changes that warrant one independent check, or when the user invokes `minerva:propose-ship-balanced`.

0
installs

25 published skills