The infinito-nexus 16.0.0 message used "-" bullets on top of a
CHANGELOG.md whose older entries used "*". The standalone lint passed,
but MD004's default "consistent" style takes the marker of the first
list in the file, so the repository's own markdown lint reported every
older list and the pre-push gate refused the push.
The message now takes the marker the target CHANGELOG.md already uses,
and step 4 also lints a copy of CHANGELOG.md with the entry inserted,
since rules like MD004 and MD024 only fire across the whole file. Both
lint runs pass --no-globs so a config with its own globs does not lint
the whole tree as well.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
archify (tt-a1i/archify) joins the locked skills. The computed hashes of
the seven caveman and six ponytail skills move to their current upstream
content.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The skill judges any artifact, not only code: it listens for goal,
audience and constraints first, steelmans the artifact, sweeps ten
aspects from goal fit to ethics, and runs every critique point through
dialectic before it is reported. Output is the steelman, the strengths
to keep, and one ranked table where each point carries a concrete
suggestion and its evidence class. It changes nothing.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
A CI run is a snapshot of one commit, and the branch keeps moving. Triage
now starts by counting <run-sha>..HEAD; when it is non-zero, the job set
is narrowed first, by the components changed since the run and by the
error signatures of causes already fixed in that range, so no job is
investigated against stale code.
The already-fixed-by-a-later-commit class is checked against
<run-sha>..HEAD as well, never against the run's own commit, which cannot
contain a fix that landed after it.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The skill collects the commits since the newest vX.Y.Z tag, sorts them
into Breaking, Added, Changed, Fixed and Upgrade notes, and prints a
message that pkgmgr release accepts on the first try.
Its format rules follow where pkgmgr writes the message: section labels
are plain "Label:" lines because git tag -a -m strips every # line from
the tag, bullets stay on one line because RPM and Debian turn each line
into its own entry, and the length limit is the repo's own MD013. The
message is linted the way pkgmgr lints it, with markdownlint-cli2 on the
wrapped entry from the repository root, so pkgmgr's line N maps to
message line N - 4.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Sandboxed agents see only their own processes, so candidates need 24 hours without change. Selection runs as checklists followed by a radio-button confirmation; stopped containers and volumes get their own warned checklist and are never dropped silently. Image removal is followed by an age-filtered build cache prune, long deletions go through a checked list file, and a refused delete is put back to the operator instead of being routed around.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
New portable skill: polls local agent sessions for what they still need, inventories /tmp, Docker and the agent write scope, classifies candidates by risk, and deletes only what the operator ticks through radio-button and checklist questions.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
The installer enabled the caveman and ponytail plugins and registered the
autotune and dream reminder hooks in the target's .claude/settings.json. That
file is the project's reviewed, version-controlled policy, so an install
rewrote a tracked file and the hooks block turned up in the working tree of
whoever ran the install, in a repository that never asked for them.
The patch now lands in .claude/settings.local.json instead, the machine-local
and untracked sibling Claude Code reads with higher precedence. Nothing else
changes: enable-plugins.js derives the reminder paths from the settings file's
own directory, which is still .claude, and it creates the file when it does
not exist.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The existing rule demands a negative control for a check the author writes. It
says nothing about a check the author cites as the reason a change is safe, and
that gap is what a 42-day CI regression rode through.
Measured in infinito-nexus-core on 2026-09-18. A sweep renamed twelve workflow
files, and its commit message claimed a lint guarded exactly that rename. The
lint's docstring promised "every workflow file named anywhere in the repository
exists". Its pattern required a directory prefix, so a bare filename was
invisible: it reported zero offenders while twenty real ones sat in the tree,
one of them a `gh workflow run` at a file that no longer existed. GitHub
resolves such a name to the deleted workflow's tombstone and answers HTTP 422,
so the scheduled release job failed on 41 consecutive runs and nobody read the
regex.
Reading the pattern instead of the prose, and watching the check fail on the
case being trusted to it, costs a minute and would have caught it on day one.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Three corrections in one window on 2026-09-18, all the same shape. Asked for a
selection-token list, returned an optimized one: "nein nicht optimieren". Asked
for the line that triggers a run, returned the line wrapped in a full
`gh workflow run` command: "du solltest es mir nur ausgeben!", then "nur die
zeile". Each cost a round trip on a deliverable that was already finished.
Rules 1 to 3 govern what gets created, files, commands, commits and `git add`.
None of them reaches the shape of a hand-over, which is message composition
rather than artifact creation, so a narrowing qualifier and an unrequested
wrapper both passed. Rule 4 closes that, and the trigger now names the case.
Autotune first proposed this as a standalone `output-only` skill. That violated
its own rule against writing a skill for behaviour an existing one covers, and
two skills with overlapping descriptions would compete when either is selected.
The delta is folded in here instead and the draft was deleted before it landed.
This does not bind on its own: nothing in the collection and no always-loaded
file invokes scope-guard, so it fires only when it is recognised and called.
The infinito-nexus-core project carries the same rule as an agent memory, which
loads without an invocation.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Eight findings, none of them in a skill written recently, all of them loud enough to hide the next real one. merge-fix opened two code fences without a language, and no-defaults wrote its table separator as |---|---|---| while all six data rows put spaces around the pipes, which markdownlint reads as a style contradiction and reports six times over for that single line.
Nothing about the rendered documents changes: the fence language only selects highlighting, and the separator row is not rendered at all. make test now passes end to end, so the next finding it reports will be a new one.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Break risk was the half of the confidence block with no method behind it. The fix-confidence half at least pointed at a claim that had been verified; the break-risk half was a feeling with a percent sign, and it was wrong in the direction that costs the operator: too low, because nothing forced an enumeration before the number was written.
The skill makes the number a consequence of six questions. Enumerate every consumer against the committed state rather than the working tree, because a symbol with no caller in your branch may still have nine elsewhere. Measure the delta where it becomes observable, not in the source: a port sweep that read as sixteen forwards produced zero in production because the flag it gated on was unrendered template text, and a risk sized against the apparent behaviour would have been sized against something that never ran. Separate live from latent and report both. Walk the deployment matrix and give a verdict per cell instead of averaging two modes into one figure that is wrong in both. Weigh the failure mode, because a fail-open exposure outranks a likelier fail-closed one. And treat subagent reports, conversation summaries and your own earlier messages as claims to re-verify rather than as evidence.
Anchors for the bands, and the rule to discount yourself in any area where the operator has already caught you out, so a region with a bad track record gets a worse number than its paper evidence suggests.
confidence now calls it every time and reports what it produces instead of estimating its own second number. The MD032 blank line is what markdownlint wants in that file.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Skills and MEMORY.md grow by accretion, and the cost is not spread evenly. MEMORY.md and every skill description load into every session; bodies load only when the skill fires; memory files only on recall. A 200-line body that fires twice a month costs less than four bloated pointers. essence ranks the work that way and reports the saving for the always-loaded surface separately, because that is the number the run exists for.
A health pass runs before anything is cut: pointers without a file and files without a pointer, dead wikilinks, memories citing a file:line that no longer exists, one rule restated across several skills, a first-party skill shadowing a locked one, and a description that says what a skill does but never when it fires. Dead entries are deleted rather than compacted, and nothing is compacted around a stale citation, or the error survives in denser form.
Two things are never cut: the evidence behind a memory, because a rule stripped of its incident degrades into an exhortation and stops changing behaviour, and any fact with no other home. Two memories whose evidence differs are never merged.
Writing is in place, since an essence beside the original saves nothing. Guarded by a clean git status for the rewritten paths, .pre-essence copies for ~/.claude and ~/.agents which are not under git, and a diff with the saved lines and characters before one confirmation. Scope is asked with checkboxes and nothing outside it is touched.
autotune routes its optimisation step here instead of trimming by hand. essence still asks for its scope on that path; the operator answers with the skill being optimised.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The skill already required naming what keeps the number below 100 and what would close the gap. The failure sat one step later: a triage invocation asked to investigate to 95 percent confidence and at most 5 percent break risk, the answer came back at 88 and 6, and the work simply moved on. The operator then had to ask three separate times how to move the numbers.
A number the operator named is now a gate on the work rather than a field in the report. A block that misses it is a work item: name the cheapest evidence that closes the gap, go get it, re-measure. A miss is reported only when that evidence is genuinely out of reach, and then it says which.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Two incidents in one session: a permanent CLI subcommand invented for a migration that runs exactly once, deleted again on demand; and `git add -A` twice sweeping local operator config into a bundle it had nothing to do with.
scope-guard states the test — which sentence of the request asks for this? No sentence, no artifact — and three rules under it: no permanent scaffolding for a one-off need, path-scope every `git add`, and report an adjacent defect in one line instead of quietly fixing it into someone elses commit.
commit-next draws the same line where staging actually happens. Step 4 is now the only place that stages: never to run a lint or a test, and always path-scoped, because `git add -A` collects work that was never part of the bundle.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The audit deletes comments, and nothing stopped it from taking live code or the operator index along. A line filter over nginx.conf.j2 removed a lone `#}`; the still-open `{#` then swallowed both map directives the edit was meant to add, the comment lint reported `2 passed` over the result, and Jinja parsed it without complaint. Two green signals, one silently disabled config.
Block-comment languages are now excluded from line filtering, with a delimiter count and a re-parse when a block is removed by hand. Verification moves from "the lint is green" to a diff against `git show HEAD:<path>`, because a swallowed block stays syntactically valid. Staging is no longer a precondition for running a check: only an untracked NEW file is invisible to a `git ls-files` walk, so staging a tracked, modified file changes nothing except an index the operator then has to undo.
The re-stage clause from the old step 3 survives at the end of step 5, now scoped to exactly the files that were staged before the audit.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The rule already lived in triage and still did not fire. `gh run view --log` refuses while a run is in progress, and that refusal read as "logs unavailable" rather than "use the other endpoint", so the investigation fell back on reasoning and produced a root cause the artifact disproves.
The new ci-artifacts skill carries what was missing: per-job logs via `gh api /repos/<owner>/<repo>/actions/jobs/<id>/logs`, which bundle to pull, reading an access log as a timing witness (499 versus 504, ReqTime versus UpstreamTime), and the grep hygiene that stops a substring match — `h2c` inside `veth2cb3f8c` — from becoming a root cause.
triage gains the rules the artifact step lacked: a derived source (a conversation summary, an earlier message, a subagent report) is not evidence; cluster assignments are re-derived after a context compaction; and every per-job verdict must cite the artifact path and line.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
A bundle was committed on the assumption that it was new. Nobody checked
whether another branch already carried the same fix, so the same defect got
solved twice and the second solution had to be reconciled by hand at merge
time - or worse, silently won.
The search that answers this already exists in merge-fix, but merge-fix
refuses a dirty tree and commit-next is dirty by definition. So only its
search steps are borrowed: fetch every ref, then grep the log by message, by
symbol and by path. No cherry-pick, no merge, no touching the staging index.
A hit is a stop, not a warning. The staged version and the foreign commit go
into dialectic as thesis and antithesis, and the operator gets sha, branch,
both diffs, the verdict and one recommended move - keep staged, take theirs,
or combine. Committing anyway would decide that question by accident.
Nothing found, or the operator picks the staged version, and the old flow
continues unchanged from commit-no-verify onwards.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Both skills changed upstream, so the pinned computedHash no longer matched what an install pulls. Nothing else in the lock moved: same sources, same skillPath, same version.
make test is green - 29 tests, including the lock's own completeness and ordering checks and the frontmatter validation that now also covers status-matrix, sceptic and auto-feature.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Deciding what to build next was an ad-hoc act: whatever the operator happened to notice. Two lenses see different work and neither is optional. The code has defects of structure - a truth held twice, a unit with two reasons to change, an input that reaches a sink unvalidated. The product has gaps of use - no --help, a stack trace where a remediation belongs, no dry-run, no empty state, a capability reachable only by reading the tests.
sceptic supplies the first lens and is read-only, so running it as a pass costs nothing. The usability lens is written out as six categories, each anchored in something observable in the repository: an invented persona produces invented requirements, so a gap that cannot be anchored is dropped rather than argued.
Both lists merge, deduplicate where a structural finding and a usability gap describe the same defect, and rank by blocked users before blast radius. Only then does the operator get asked - active-listening first removes every question the code, the docs or the history can answer, and what remains goes out as radio buttons where every option is a real alternative, including fix the structure instead and document the limitation and defer.
The output is requirement documents and nothing else: one per feature, each traced to file:line evidence, each recording the alternatives that were rejected and why, so the next reader does not re-propose them. No implementation, no refactor, no staging.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
code-review hunts bugs, ponytail-audit hunts bloat, medusa hunts secrets. Nothing asked the structural question: where does this codebase hold one truth in two places, mix two reasons to change in one unit, or trust an input it never validated. Those defects pass every test and every linter.
Six lenses, each with a falsification test rather than a feeling: DRY demands the proven shared reason to change, so two blocks that merely look alike stay separate; SRP demands two nameable stakeholders; security stays at the trust boundaries and stays defensive. The silent-defaults lens routes to no-defaults instead of restating it.
The rules exist to keep the report worth reading. A finding carries file:line the agent actually read, one hit is not a pattern, and a finding whose worst case is "feels wrong" is deleted rather than softened - the expensive ones go through dialectic first. A deliberate ponytail: marker is a known ceiling, not a finding.
Read-only by construction, so auto-feature can run it as a first pass without side effects.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Answering "where do we stand" took three separate questions: what is done, what is still running, and how sure the agent is. confidence answers only the last one, and only for a bundle it just staged; observe watches a single named target and speaks only when that target changes. Neither gives the whole picture on demand.
The skill reads the todo list, the working tree, live background jobs and agents, and the branch's PRs with their checks, then prints one table - item, state, fix confidence, break risk, evidence or next step - followed by at most three lines for blocked, residuals and running.
It is read-only by construction: no edit, no stage, no deploy, no started work. The percentages route to confidence instead of inventing a second scale, and done means verified, so work that merely looks finished stays open. A source that could not be read produces no row rather than a guessed one.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The harness writes it into the checkout next to the rendered .agents/ and .claude/ install targets, so it belongs to the same ignored group.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Fetches every ref, searches commit messages, content and paths for the fix described in the skill argument, drops what HEAD already contains, and brings the survivor over via cherry-pick or a no-ff merge. Dirty trees are refused up front so no stash or checkout can eat another agent's uncommitted work in the shared tree.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
autotune, autoskill and confidence each carried their own idea of what an
improvement is, and autotune's two efficiency rules were the same sentence
twice. They now route to one skill that names three axes to move at once —
fewer tokens, less time, higher quality — and the rules that decide when a
proposal counts: at least one axis better, none damaged, quality never the
currency, observed friction instead of a guessed percentage.
Applying its own rule, autotune gets shorter rather than longer. The test
holds the coupling, so a later rewrite cannot silently drop a route.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
A skill written only under .claude/skills is lost on the next install, and
one written only into the skills repository is not live until the next
restart, so both writers now do both: locate the operator's skills
repository through an ordered first-hit lookup, write the source of truth
there, then mirror the whole skill directory into the live locations so
hooks and references come along.
The lookup ends in a question to the operator rather than a silent skip
when no repository matches. autoskill routes to the same section instead
of carrying its own copy of the paths.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Replay the last 24h of a repository — git log and reflog, CI, reviews,
memory, session transcripts — score every action as held, broke or unknown
against its evidence, harden the resulting hypotheses with dialectic, and
persist what survives. The objective is a measurably more confident next
run: a class of error counts as closed only once a test, check, hook or
written rule prevents it.
Derived improvements to the code and to the agent instructions are offered
as single-select questions, and the run ends in autotune and autoskill.
The reminder hook stamps into each repository's git dir, so every repo
carries its own twelve-hour cadence and the hook stays silent outside a
git repository.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Turn a request into a plan whose every item is an outcome with a
verification, then execute it. The run opens with active-listening, since
robot never asks once it starts, and it implements the whole plan
statically before robot takes over the run-deploy-observe-fix loop.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Move the artifact-download guidance out of the generic dialectic loop and
into triage, where it now runs per error-message cluster instead of per
failing job: group the failing jobs by their actual failing line, fetch one
representative's artifacts per cluster, and run the dialectic per cluster.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
A job log usually names an artifact path and stops there; the assertion
text, server exception and state dumps live inside the artifact. Both
triage and dialectic now require downloading them before forming a
thesis, since theorising from the log alone while an unread artifact
holds the answer is the most expensive mistake in the loop.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Reuses the test skill for discovery and owns the loop after the first
red result: one root cause and one fix per iteration, with explicit
stop conditions so a stuck loop reports instead of thrashing. Skipping
or loosening tests is a report item, never a fix.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Discovers test* targets from the Makefile instead of guessing a runner,
so the project's env vars and build prerequisites are not bypassed, and
offers them as a selection list.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Before editing, the skill now establishes a safety net: run existing
coverage for a green baseline, or write characterization tests against
the current behaviour where the code is testable logic. Those tests must
still pass unchanged afterwards, so a test that had to be edited means
the refactor moved behaviour and gets reverted.
The refactor itself is now governed by SRP, SPOT, KISS and DRY, and no
file containing program code may exceed 250 lines. Description and
markup languages are exempt, as is a file the language or framework
genuinely forbids splitting.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The skill refactors every file that is currently uncommitted in the git
working tree up to the project's coding standards, without changing
behaviour and without widening the scope to untouched files.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
The skill generates new skills and optimizes existing ones for token
usage, error rate, focus and persisted learnings. Every decision is
confirmed through single-select (radio button) questions, and the skill
only runs on an explicit operator trigger.
A UserPromptSubmit hook reminds the operator at most once an hour that
/autotune exists; the reminder is a hint for the operator, never a
trigger for the agent. The install-time settings patch registers it
alongside the caveman and ponytail plugins.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Forbids substantive defaults for parameters, settings and env lookups
across languages; only false, null and "" are free. A missing value
must fail loudly at the earliest point instead of silently becoming a
plausible wrong answer.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Add the observe skill: /observe <target> drives a dynamic /loop that polls a named CI run, pipeline, build or log, diffs the failures against a session baseline, and applies triage (hence dialectic per job) to newly appeared failures only. Chains onto the existing triage and dialectic skills; hardened against re-triaging fixed failures and against idle-polling harness-tracked work.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
- active-listening: gather every requirement before acting; ask until nothing
needed is open, then reflect back.
- dialectic: thesis / adversarial antithesis / synthesis looped to a ~99%
thesis, deep-inspecting every accessible source; calls active-listening.
- triage: drive a failing pipeline to green by applying dialectic to every
failing job independently.
- robot: autonomous-execution contract - no questions once the goal is clear,
never stop before it is reached, only cleared (non-denied/non-ask) commands.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
comments-clean purges explanatory comments before every operator-requested stage or commit and penalizes own violations into persistent memory; commit-no-verify commits the exact staging index with hooks skipped, the invocation itself being the per-commit authorization; commit-next chains both and stages the next logical bundle with an explain and confidence briefing; explain walks code and its collaborators in execution order and offers a Mermaid schema in the affected README; help-skills lists every project, global and plugin skill with triggers and composition.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Rename the portable conversation-shortcut skill from agent-shortcuts to
shortcuts and re-prefix every token to soc* (sobu, soco, socobu, socon,
sona, sote) so each token mirrors its command and never places two
consonants next to each other. make install and make project now also
register the caveman and ponytail marketplaces and enable both plugins in
the target's .claude/settings.json so their SessionStart hooks activate
every session; the merge is non-destructive, idempotent, and leaves an
unparseable settings.json untouched.
- skills/shortcuts/SKILL.md: new name and soc* token table
- tests/test_shortcuts.py: assert present, sorted, soc-prefixed, no cluster
- remove skills/agent-shortcuts and tests/test_agent_shortcuts.py
- scripts/enable-plugins.js: node JSON merge helper
- scripts/install.sh: run the helper after copying skills
- README.md: document the auto-enable behavior
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
- add ponytail skill set to skills-lock.json (14 locked skills total)
- add first-party medusa skill under skills/, layered on install
- make test now runs ruff, shellcheck, and markdownlint-cli2
- CI installs the lint tools before make test in both workflows
- MIT license, funding buttons, thanks and donation sections in README
- .markdownlint-cli2.jsonc config; ignore lint caches in .gitignore
- skills-lock.json pins every skill (extracted from infinito-nexus-core)
- make install (global to $HOME) and make project TARGET=<repo> copy the
rendered skills into .agents/skills + .claude/skills
- make update refreshes the lock via npx skills; make test validates the
lock shape and shellchecks the scripts
- CI: test workflow on push/PR, daily update workflow opening a PR
- MIRRORS for code.infinito.nexus and git.veen.world
