v0.2.0 — Slim + Pluggable (BREAKING)

RePERS v0.2.0 — Slim + Pluggable (BREAKING)

The first breaking release in the v0.2 line. Turns RePERS from a 30+-verb
harness with hardcoded logic into a 6-verb pipeline with one plugin slot
per stage plus a deterministic per-task router that decides which
slice fires.

Why this is a major release

v0.1.x was right about the philosophy (Research → Plan → Execute → Review
→ Ship) but wrong about the surface — too many META verbs that only the
maintainers of RePERS itself ever called. v0.2 cuts that surface and makes
the remaining one substitution-friendly: any stage's implementation can
be swapped without forking the harness.

What changed

New — slim + pluggable architecture

• .repers/contracts/ — 7 versioned JSON Schemas, one per pipeline
  stage. The stable shapes that flow between R-P-E-R-S stages.
• .repers/plugins/ — convention plugins/<verb>/<name>.py. Ships
  with default.py for each verb (wrapping the existing implementation).
  Select alternates via REPERS_PLUGIN_<VERB>=<name> env var.
• .repers/scripts/plugin_loader.py — discovers + imports plugin
  module by (verb, name). Legacy fallback when no plugin folder exists.
• All 6 pipeline verbs (route, preflight, plan, dispatch, review,
  shipping) resolve via the plugin loader.

Breaking — 4 CLI verbs removed

Removed verb	Removed script
objective-audit	objective_audit.py
continue	continuation_runner.py
snapshot-freshness	snapshot_freshness.py
open-source-benchmark	open_source_benchmark.py

These were specific to RePERS's own v0.1 publication objective and had no
value to receivers.

Breaking — state slimmed

• Removed state.objective.{complete,blocking_incomplete} and state.next.* fields
• Removed --deep and --objective CLI flags
• Output is now git / package / capabilities only

Breaking — registry trimmed 25 → 20

Removed: objective-audit, continuation-runner, state-report (meta
entry), snapshot-freshness, open-source-benchmark.

Breaking — release-pack artifact set trimmed

REQUIRED_RELEASE_PACK_ARTIFACTS no longer includes
open_source_benchmark_json / objective_audit / continuation_markdown.

Migration for receivers

If your CI / scripts call removed verbs:

Was	Do this
repers.py objective-audit	drop — no replacement, was internal
repers.py continue	drop
repers.py snapshot-freshness	drop, use git status dist/
repers.py open-source-benchmark	drop
repers.py state --deep --objective "..."	repers.py state --json (slim only)
reads of state.objective.complete	gone — write a plugins/state/<name>.py if you need a richer signal

Substitution path (the new product)

# write a custom router (LLM-based) in 1 file:
cat > .repers/plugins/route/llm.py <<'EOF'
NAME = "llm"
def route(task, repo_root, est_files=None, **kw):
    # call your LLM, return a repers.router.v1-conforming dict
    ...
def format_human(payload): return payload["recommendation"]
EOF

# select it:
REPERS_PLUGIN_ROUTE=llm python3 .repers/scripts/repers.py route --task "..." --json

Same pattern for preflight, plan, dispatch, review, ship.

Stats

• Capabilities: 25 → 20
• Installed files: 59 → 55
• Scripts: 25 → 21 (4 META deleted)
• CLI verbs: 32 → 28
• Plugin slots: 0 → 6
• Stage contracts as files: 0 → 7

Assets

• repers-0.2.0.zip — installable runtime archive (775 KB)
• repers-release-pack.zip — transferable evidence bundle (781 KB)
• repers-verify-all.json — local-gate evidence

What's next (v0.3)

See ROADMAP.md. Headline items: .repers/config.yaml for pinning
plugins per repo, agent-fixture proving non-Claude vendors plug in
end-to-end, optional jsonschema validation of plugin outputs.

v0.1.1 — Router shipped, ceremony-budget honesty

RePERS v0.1.1 — Router shipped, ceremony-budget honesty

The v0.1.1 release is a product-honesty release. After driving the full
R-P-E-R-S CLI end-to-end on a real bug (sqlfluff__sqlfluff-2419) and
measuring 5.8× wall-clock overhead vs. a naked agent for a 4-line fix
with no quality lift, we shipped the missing product piece: a router that
tells you when NOT to use the harness.

What's new

🧭 Router (the headline)

python .repers/scripts/repers.py route \
  --task "fix the L060 description bug" --est-files 1 --json
# → permutation: R-E-R
#   reason: "estimated 1 file(s) — naked agent is faster"
#   recommendation: "Naked agent loop is fine: read, edit, verify.
#                    The harness ceremony will cost more than it saves."

A deterministic keyword + repo-signal decision tree that maps any task
description to one of:

Permutation	When
skip	Trivial — don't even invoke the harness, use your IDE
R-only	Spike / scoping — write a research note, decide later
R-S	Docs / config — skip execute, just review + ship
R-E-R	Hotfix / single-file — naked agent loop is faster
R-P-E-R	Multi-file in one domain — plan + parallel dispatch wins
R-P-E-R-S	Multi-domain, multi-day — the full pipeline sweet spot

<100 ms, no LLM call, offline, stdlib-only. Validated against the real
sqlfluff bug: it would have correctly routed away from the 5.8× overhead.

🪝 /repers-bug-hunt now routes first

Hard-coded to short-circuit on skip / R-E-R. No more 7-mandatory-step
pipeline on a 4-line bug. Skill description and procedure rewritten to
make the routing step explicit.

🛠️ Two CLI UX fixes (from the end-to-end dogfood)

1. review --update-status now also refreshes plan.json — removes
   the "you forgot to re-plan before the next run" gotcha. Review output
   includes status_update.plan_json_refresh: {refreshed: bool, error}
   so callers can observe the sync.
2. verify-install emits an actionable hint field when the only
   failure mode is sha256 mismatches on tracked files — carries the
   exact refresh-manifest command to fix it (the overwhelming
   "I edited a script in place" case).

📖 Real end-to-end walkthrough

docs/e2e-walkthrough.md
records every CLI command from init through shipping on a real
multi-file task, with 3 parallel agent workers, 45 s wall-clock total,
and both UX gotchas honestly documented.

🎯 Repositioning (docs)

• README hero rewritten: operating layer for multi-agent repository work
  (not "local-first harness").
• New top-of-fold "When to use / When NOT to use" section with the
  5.8× sqlfluff data point.
• New "5 stages — and when each fires" permutation table.
• CITATION.cff abstract positions RePERS as the contract layer above
  agent runtimes (LangGraph / CrewAI / OpenHands), not a competitor.
• ROADMAP gains an "Out of scope" section.

Stats

• Capabilities: 24 → 25 (route added)
• Skills: 4 → 5 (/repers-route added)
• Installed files: 42 → 43 (router.py added)
• Existing scripts: 3 META scripts got module docstrings (dag_engine.py,
  state_report.py, snapshot_freshness.py) — fixed via the harness
  itself in the dogfood.

Upgrading from v0.1.0

# Codex plugin:
/plugin marketplace update repers
/plugin update repers   # or uninstall + install if cached
# (then restart Codex if the skill description still looks old)

# Repo-local runtime:
git pull
python .repers/scripts/repers.py refresh-manifest --json
python .repers/scripts/repers.py verify-install --json

Assets

• repers-0.1.1.zip — installable runtime archive
• repers-release-pack.zip — transferable evidence bundle
• repers-verify-all.json — full local-gate evidence

What's next (v0.2)

See ROADMAP.md.
Headline items: a real "harness wins" example (multi-file SWE-bench Verified
walkthrough), a WORKER.md contract spec, a registry trim from 25 → ~16,
and router signal extensions (preflight hit count + similar-PR git-log
overlay).

v0.1.0 — initial public release

RePERS v0.1.0 — initial public release

First public release of the RePERS harness. Reusable Planning,
Execution, Review, and Release — a local-first agent workflow
operating layer.

What's in the box

• .repers/ runtime — stdlib-only Python CLI (repers.py) with subcommands for preflight, planning, dispatch, review, packaging, hooks, and a full local verification gate.
• 24-entry capability registry — canonical inventory of reusable workflows, scripts, hooks, gates. Queryable via repers.py capabilities.
• 4 Codex skills — repers-init, repers-bug-hunt, repers-release-pack, repers-sinkin.
• Deterministic orchestration fixture — fixture --action prove validates conflict-safe worker dispatch + join/review WITHOUT a real agent backend.
• Installable Git pre-commit hook — warn (default) or strict mode.
• Transferable release pack — repers-release-pack.zip (install archive + readiness + handoff + remote bootstrap + benchmark + state + continuation, all checksum-verifiable).
• JSON evidence for every gate — pipe to jq, store in CI, audit later.

Quickstart

# As a Codex plugin:
/plugin marketplace add coolsocket/repers
/plugin install repers
/repers-init

# OR as a repo-local runtime:
git clone https://github.com/coolsocket/repers.git
python repers/.repers/scripts/repers.py install --target /path/to/your-repo --json

See the README for the daily
workflow and the FAQ.

Assets

Asset	Purpose
repers-0.1.0.zip	Installable runtime archive (extract → run install_repers.py)
repers-release-pack.zip	Transferable bundle for another repo to verify end-to-end
repers-verify-all.json	Full local-gate evidence (328 KB)
repers-release-evidence.json	Publish-readiness report (package + registry + governance + Git state)

What's next

See ROADMAP.md —
next milestones include richer DAG planning artifacts, branch/PR automation,
and (later) optional CodeGraph + signed artifacts.

Contributions welcome — start with CONTRIBUTING.md
and please run preflight --query "<your-intent>" before proposing new
capabilities.