slopkeeper 0.1.0__tar.gz

slopkeeper-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Greg Brandt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

slopkeeper-0.1.0/PKG-INFO

@@ -0,0 +1,262 @@
+Metadata-Version: 2.4
+Name: slopkeeper
+Version: 0.1.0
+Summary: A SlopKeeper for agent-slop corpora. Inventory, partition and scaffold messy file corpora into agent-navigable folder-bots. Agent-first CLI: JSON envelope, next-step hints, hard safety gates.
+Author: Greg Brandt
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/brandtg/slopkeeper
+Project-URL: Repository, https://github.com/brandtg/slopkeeper
+Project-URL: Issues, https://github.com/brandtg/slopkeeper/issues
+Keywords: agent,corpus,organization,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<!--
+SPDX-FileCopyrightText: 2026 Greg Brandt <brandt.greg@gmail.com>
+
+SPDX-License-Identifier: MIT
+-->
+
+# SlopKeeper
+
+Inventory, partition and scaffold messy file corpora — the tool side of
+"each folder is a bot". A calling agent (Hermes, Claude Code, anything that
+shells out) does the classification; SlopKeeper does everything else:
+inventory, plan validation, reference-integrity checking, all-or-nothing
+execution with a journal and undo, and the AGENTS.md/STATE.md layer that
+makes the result agent-navigable.
+
+**Zero dependencies. Python 3.11+ (oldest supported CPython) stdlib only. No LLM calls. No network.**
+
+## Install
+
+The only requirement is **Python 3.11+** (3.11 is what Debian 12 / RHEL 9
+ship; every common Linux distro and Homebrew Python from 3.11 up works).
+Zero dependencies, so the install is tiny either way.
+
+With [pipx](https://pipx.pypa.io) (recommended — puts `slopkeeper` on your PATH
+in its own venv):
+
+```bash
+pipx install git+https://github.com/brandtg/slopkeeper.git
+# or pinned to a tag:
+pipx install git+https://github.com/brandtg/slopkeeper.git@v0.1.0
+```
+
+With plain pip (in a virtualenv, or `pip install --user` if you prefer):
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install git+https://github.com/brandtg/slopkeeper.git
+```
+
+From a local clone instead of GitHub:
+
+```bash
+git clone https://github.com/brandtg/slopkeeper && cd slopkeeper
+pipx install .            # or: python3 -m pip install .
+```
+
+If you have [uv](https://docs.astral.sh/uv/), `uv tool install .` (or
+`uv tool install git+https://github.com/brandtg/slopkeeper.git`) is
+equivalent to the pipx commands.
+
+Verify:
+
+```bash
+slopkeeper --version
+```
+
+> **PyPI:** not published yet. Until then, install from this repository
+> with the commands above; once published it will be a plain
+> `pipx install slopkeeper`.
+
+### Run from a checkout without installing
+
+```bash
+PYTHONPATH=src python3 -m slopkeeper doctor ~/workspace
+```
+
+## Agent setup
+
+SlopKeeper's whole model is *agent classifies, human approves, SlopKeeper moves* —
+so the other half of installing it is making sure your agent knows how
+to drive it. The canonical protocol ships **inside the package**:
+
+```bash
+slopkeeper guide    # prints AGENT_GUIDE.md — the full agent protocol
+```
+
+Point your agent at that once and it has everything: the protocol, the
+error codes, the recovery hints. If your agent reads skills
+(SKILL.md format — Claude Code, Hermes, and others), install the
+shipped one, which is a thin wrapper that tells the agent to run
+`slopkeeper guide` and recites the non-negotiables:
+
+```bash
+# Claude Code
+mkdir -p ~/.claude/skills && cp -r skills/slopkeeper ~/.claude/skills/
+# Hermes
+mkdir -p ~/.hermes/skills/software-development && cp -r skills/slopkeeper ~/.hermes/skills/software-development/
+```
+
+The full guide also lives in the repo (AGENT_GUIDE.md) and in the docs
+site (`docs/site/`), so agents in a checkout can read it directly.
+
+## The model
+
+```
+inventory → agent drafts plan → validate → render (HUMAN GATE)
+          → apply --execute → scaffold → done (undo possible)
+```
+
+**Tending a corpus that's already organized** (the usual case after the
+first sweep) is the cheap loop: `status` diffs against the last tend's
+manifest, the agent triages only the new slop, and a delta plan moves
+just that. See AGENT_GUIDE.md — "Re-tending".
+
+- **inventory** — structured JSON of the corpus: files, heads, titles,
+  dir stats, date/prefix/ext clusters, and a cross-reference index of
+  which files mention which filenames. Token-conscious modes for big
+  corpora (`--fast --summary`).
+- **clusters** — similarity hints for the planning agent: TF-IDF content
+  clusters, scrape pairs, byte-identical copies, hub files. Hints, never
+  a plan.
+- **status** — diff since the last tend (manifest in `.slopkeeper/`):
+  new/modified/removed files, folder health, still-unresolved items.
+  `--all` returns one count-level digest over every registered root.
+- **roots** — registry of tended corpora at
+  `$XDG_CONFIG_HOME/slopkeeper/roots.json` (`SLOPKEEPER_HOME` overrides):
+  `roots add/remove/list`, feeding `status --all` for scheduled tending.
+- **plan** — the only write path. A JSON document of `moves` (from → to +
+  reason), `keep`, `unresolved`, `folders` (to scaffold), and the corpus
+  fingerprint it was authored against (`based_on.corpus_fingerprint`,
+  named `inventory_sha256` in older plans — still accepted). Validated
+  hard: path escapes, stale sources, collisions, nested moves, cycles,
+  incomplete coverage.
+- **apply** — all-or-nothing execution. Dry-run by default; refuses a
+  corpus whose fingerprint changed since planning; pre-flights every
+  destination before touching anything; journals every move with a
+  content hash; flags every move cited from stay-put files. Records the
+  manifest on success.
+- **scaffold** — writes the folder-bot layer: root `AGENTS.md` roster,
+  per-folder `AGENTS.md` and `STATE.md`. Never overwrites — existing
+  files get a `*.slopkeeper-suggested` sibling instead.
+- **undo** — reverses a journal exactly (restores, prunes empty dirs).
+- **strategies** — partitioning rubric packs the agent reads: `role-bots`
+  (folder-as-bot), `topics`, `projects`, `hybrid` (default).
+- **doctor** — preflight: size, messiness, strategy suggestion, token
+  estimate, advice.
+
+```bash
+# from a checkout (no install needed)
+PYTHONPATH=src python3 -m slopkeeper doctor ~/workspace
+PYTHONPATH=src python3 -m slopkeeper inventory ~/workspace --fast --summary
+PYTHONPATH=src python3 -m slopkeeper clusters ~/workspace   # similarity hints
+PYTHONPATH=src python3 -m slopkeeper status ~/workspace     # diff since last tend
+PYTHONPATH=src python3 -m slopkeeper roots add ~/workspace  # register for status --all
+PYTHONPATH=src python3 -m slopkeeper draft ~/workspace      # auto-draft delta plan
+PYTHONPATH=src python3 -m slopkeeper refs ~/workspace X.md  # citation sites
+PYTHONPATH=src python3 -m slopkeeper strategies show hybrid
+PYTHONPATH=src python3 -m slopkeeper plan schema
+PYTHONPATH=src python3 -m slopkeeper guide              # the agent protocol (also in the wheel)
+
+# installed (pipx install git+https://github.com/brandtg/slopkeeper.git — see Install above)
+slopkeeper apply plan.json ~/workspace --execute
+slopkeeper undo .slopkeeper/journal-20261103T074342Z.jsonl ~/workspace
+# undo takes exactly one journal; name it (see .slopkeeper/journal-*.jsonl)
+```
+
+Agents: read **AGENT_GUIDE.md** before driving this. Humans: the plan
+markdown (`plan render`) is your approval gate — read it, edit the JSON,
+or say no.
+
+## Test
+
+```bash
+python3 -m unittest discover -s tests
+```
+
+## The REPL (bare `slopkeeper`)
+
+Run `slopkeeper` with no subcommand and you get an interactive `/command` prompt —
+the human front door for exploring a corpus and tending it by hand. It
+drives the exact same functions as the JSON subcommands (no new write
+path); every `--execute` stops for an explicit y/N, and the default is no.
+
+```text
+$ slopkeeper
+slopkeeper 0.1.0 — /help repeats this list; /quit to leave.
+the same commands as `slopkeeper <subcommand>`, human-rendered:
+  /use <path>        set the corpus root
+  /status            what changed since the last tend
+  /new               the new slop, with titles and heads
+  /doctor            preflight summary
+  /inventory         corpus stats and fingerprint
+  /clusters          similarity hints
+  /refs <basename>   citation sites for a filename
+  /cat <file>        show a corpus file
+  /strategies [id]   list rubrics / show one
+  /draft             auto-draft a delta plan for new root slop
+  /load <plan.json>  load a plan (e.g. one your agent wrote) to review
+  /moves             list the working plan's moves
+  /show <n>          show the file a move would relocate
+  /ok <n|all>        clear a decision on move n
+  /no <n>            drop move n — the file stays where it is
+  /defer <n> [why]   send move n to the unresolved backlog
+  /dest <n> <to>     re-destination move n
+  /plan              compile decisions, validate, save
+  /render            show the rendered human-gate markdown
+  /apply             dry-run, confirm, execute the plan
+  /scaffold          write the AGENTS.md layer (confirm)
+  /undo [n] [!]      list journals / dry-run / execute one
+  /quit              leave (Ctrl-D also works)
+> /use ~/Documents/notes     # point it at a corpus
+> /status                    # what changed since the last tend
+> /new                       # the new slop, with titles
+> /draft                     # auto-draft a delta plan (saved in .slopkeeper/)
+> /moves                     # walk the proposed moves
+> /show 1  /no 1  /defer 1  /dest 1 api/   # decide per move
+> /plan                      # compile decisions, validate, save
+> /render                    # read the human gate
+> /apply                     # dry-run → [y/N] → execute
+> /scaffold                  # [y/N] → write the AGENTS.md layer
+> /undo                      # list journals, dry-run, execute
+```
+
+Readline history persists at `~/.local/state/slopkeeper/history` (arrows,
+Ctrl-W and friends all work), and **Tab completes**: command names,
+filesystem paths one component at a time (`/cat docs/can` → tab →
+`/cat docs/canonical.md`), and move/journal numbers.
+
+`/load <plan.json>` brings in a plan your agent wrote so you can review it
+move by move. First-tend authoring (naming a taxonomy from a full
+inventory) is agent work — point your agent at AGENT_GUIDE.md.
+
+## Design notes
+
+- The hard parts of corpus organization are *judgment* (the agent's),
+  *reference integrity* (grep-before-move, baked into validate/apply),
+  and *the human gate* (rendered markdown of every move with reasons and
+  risks). The tool makes the gate cheap; it does not try to remove it.
+- Fingerprint gating means a plan can never act on a corpus it wasn't
+  written against — the "silent drift" failure mode is closed.
+- Journals are JSONL with sha256s; undo is exact and reversible, and
+  prune empty dirs it created. Nothing is ever deleted.
+- Strategies are JSON rubric packs, not code: the agent reads them like
+  documentation, and new strategies are new files, not releases.
+
+## License
+
+MIT.

slopkeeper-0.1.0/README.md

@@ -0,0 +1,237 @@
+<!--
+SPDX-FileCopyrightText: 2026 Greg Brandt <brandt.greg@gmail.com>
+
+SPDX-License-Identifier: MIT
+-->
+
+# SlopKeeper
+
+Inventory, partition and scaffold messy file corpora — the tool side of
+"each folder is a bot". A calling agent (Hermes, Claude Code, anything that
+shells out) does the classification; SlopKeeper does everything else:
+inventory, plan validation, reference-integrity checking, all-or-nothing
+execution with a journal and undo, and the AGENTS.md/STATE.md layer that
+makes the result agent-navigable.
+
+**Zero dependencies. Python 3.11+ (oldest supported CPython) stdlib only. No LLM calls. No network.**
+
+## Install
+
+The only requirement is **Python 3.11+** (3.11 is what Debian 12 / RHEL 9
+ship; every common Linux distro and Homebrew Python from 3.11 up works).
+Zero dependencies, so the install is tiny either way.
+
+With [pipx](https://pipx.pypa.io) (recommended — puts `slopkeeper` on your PATH
+in its own venv):
+
+```bash
+pipx install git+https://github.com/brandtg/slopkeeper.git
+# or pinned to a tag:
+pipx install git+https://github.com/brandtg/slopkeeper.git@v0.1.0
+```
+
+With plain pip (in a virtualenv, or `pip install --user` if you prefer):
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install git+https://github.com/brandtg/slopkeeper.git
+```
+
+From a local clone instead of GitHub:
+
+```bash
+git clone https://github.com/brandtg/slopkeeper && cd slopkeeper
+pipx install .            # or: python3 -m pip install .
+```
+
+If you have [uv](https://docs.astral.sh/uv/), `uv tool install .` (or
+`uv tool install git+https://github.com/brandtg/slopkeeper.git`) is
+equivalent to the pipx commands.
+
+Verify:
+
+```bash
+slopkeeper --version
+```
+
+> **PyPI:** not published yet. Until then, install from this repository
+> with the commands above; once published it will be a plain
+> `pipx install slopkeeper`.
+
+### Run from a checkout without installing
+
+```bash
+PYTHONPATH=src python3 -m slopkeeper doctor ~/workspace
+```
+
+## Agent setup
+
+SlopKeeper's whole model is *agent classifies, human approves, SlopKeeper moves* —
+so the other half of installing it is making sure your agent knows how
+to drive it. The canonical protocol ships **inside the package**:
+
+```bash
+slopkeeper guide    # prints AGENT_GUIDE.md — the full agent protocol
+```
+
+Point your agent at that once and it has everything: the protocol, the
+error codes, the recovery hints. If your agent reads skills
+(SKILL.md format — Claude Code, Hermes, and others), install the
+shipped one, which is a thin wrapper that tells the agent to run
+`slopkeeper guide` and recites the non-negotiables:
+
+```bash
+# Claude Code
+mkdir -p ~/.claude/skills && cp -r skills/slopkeeper ~/.claude/skills/
+# Hermes
+mkdir -p ~/.hermes/skills/software-development && cp -r skills/slopkeeper ~/.hermes/skills/software-development/
+```
+
+The full guide also lives in the repo (AGENT_GUIDE.md) and in the docs
+site (`docs/site/`), so agents in a checkout can read it directly.
+
+## The model
+
+```
+inventory → agent drafts plan → validate → render (HUMAN GATE)
+          → apply --execute → scaffold → done (undo possible)
+```
+
+**Tending a corpus that's already organized** (the usual case after the
+first sweep) is the cheap loop: `status` diffs against the last tend's
+manifest, the agent triages only the new slop, and a delta plan moves
+just that. See AGENT_GUIDE.md — "Re-tending".
+
+- **inventory** — structured JSON of the corpus: files, heads, titles,
+  dir stats, date/prefix/ext clusters, and a cross-reference index of
+  which files mention which filenames. Token-conscious modes for big
+  corpora (`--fast --summary`).
+- **clusters** — similarity hints for the planning agent: TF-IDF content
+  clusters, scrape pairs, byte-identical copies, hub files. Hints, never
+  a plan.
+- **status** — diff since the last tend (manifest in `.slopkeeper/`):
+  new/modified/removed files, folder health, still-unresolved items.
+  `--all` returns one count-level digest over every registered root.
+- **roots** — registry of tended corpora at
+  `$XDG_CONFIG_HOME/slopkeeper/roots.json` (`SLOPKEEPER_HOME` overrides):
+  `roots add/remove/list`, feeding `status --all` for scheduled tending.
+- **plan** — the only write path. A JSON document of `moves` (from → to +
+  reason), `keep`, `unresolved`, `folders` (to scaffold), and the corpus
+  fingerprint it was authored against (`based_on.corpus_fingerprint`,
+  named `inventory_sha256` in older plans — still accepted). Validated
+  hard: path escapes, stale sources, collisions, nested moves, cycles,
+  incomplete coverage.
+- **apply** — all-or-nothing execution. Dry-run by default; refuses a
+  corpus whose fingerprint changed since planning; pre-flights every
+  destination before touching anything; journals every move with a
+  content hash; flags every move cited from stay-put files. Records the
+  manifest on success.
+- **scaffold** — writes the folder-bot layer: root `AGENTS.md` roster,
+  per-folder `AGENTS.md` and `STATE.md`. Never overwrites — existing
+  files get a `*.slopkeeper-suggested` sibling instead.
+- **undo** — reverses a journal exactly (restores, prunes empty dirs).
+- **strategies** — partitioning rubric packs the agent reads: `role-bots`
+  (folder-as-bot), `topics`, `projects`, `hybrid` (default).
+- **doctor** — preflight: size, messiness, strategy suggestion, token
+  estimate, advice.
+
+```bash
+# from a checkout (no install needed)
+PYTHONPATH=src python3 -m slopkeeper doctor ~/workspace
+PYTHONPATH=src python3 -m slopkeeper inventory ~/workspace --fast --summary
+PYTHONPATH=src python3 -m slopkeeper clusters ~/workspace   # similarity hints
+PYTHONPATH=src python3 -m slopkeeper status ~/workspace     # diff since last tend
+PYTHONPATH=src python3 -m slopkeeper roots add ~/workspace  # register for status --all
+PYTHONPATH=src python3 -m slopkeeper draft ~/workspace      # auto-draft delta plan
+PYTHONPATH=src python3 -m slopkeeper refs ~/workspace X.md  # citation sites
+PYTHONPATH=src python3 -m slopkeeper strategies show hybrid
+PYTHONPATH=src python3 -m slopkeeper plan schema
+PYTHONPATH=src python3 -m slopkeeper guide              # the agent protocol (also in the wheel)
+
+# installed (pipx install git+https://github.com/brandtg/slopkeeper.git — see Install above)
+slopkeeper apply plan.json ~/workspace --execute
+slopkeeper undo .slopkeeper/journal-20261103T074342Z.jsonl ~/workspace
+# undo takes exactly one journal; name it (see .slopkeeper/journal-*.jsonl)
+```
+
+Agents: read **AGENT_GUIDE.md** before driving this. Humans: the plan
+markdown (`plan render`) is your approval gate — read it, edit the JSON,
+or say no.
+
+## Test
+
+```bash
+python3 -m unittest discover -s tests
+```
+
+## The REPL (bare `slopkeeper`)
+
+Run `slopkeeper` with no subcommand and you get an interactive `/command` prompt —
+the human front door for exploring a corpus and tending it by hand. It
+drives the exact same functions as the JSON subcommands (no new write
+path); every `--execute` stops for an explicit y/N, and the default is no.
+
+```text
+$ slopkeeper
+slopkeeper 0.1.0 — /help repeats this list; /quit to leave.
+the same commands as `slopkeeper <subcommand>`, human-rendered:
+  /use <path>        set the corpus root
+  /status            what changed since the last tend
+  /new               the new slop, with titles and heads
+  /doctor            preflight summary
+  /inventory         corpus stats and fingerprint
+  /clusters          similarity hints
+  /refs <basename>   citation sites for a filename
+  /cat <file>        show a corpus file
+  /strategies [id]   list rubrics / show one
+  /draft             auto-draft a delta plan for new root slop
+  /load <plan.json>  load a plan (e.g. one your agent wrote) to review
+  /moves             list the working plan's moves
+  /show <n>          show the file a move would relocate
+  /ok <n|all>        clear a decision on move n
+  /no <n>            drop move n — the file stays where it is
+  /defer <n> [why]   send move n to the unresolved backlog
+  /dest <n> <to>     re-destination move n
+  /plan              compile decisions, validate, save
+  /render            show the rendered human-gate markdown
+  /apply             dry-run, confirm, execute the plan
+  /scaffold          write the AGENTS.md layer (confirm)
+  /undo [n] [!]      list journals / dry-run / execute one
+  /quit              leave (Ctrl-D also works)
+> /use ~/Documents/notes     # point it at a corpus
+> /status                    # what changed since the last tend
+> /new                       # the new slop, with titles
+> /draft                     # auto-draft a delta plan (saved in .slopkeeper/)
+> /moves                     # walk the proposed moves
+> /show 1  /no 1  /defer 1  /dest 1 api/   # decide per move
+> /plan                      # compile decisions, validate, save
+> /render                    # read the human gate
+> /apply                     # dry-run → [y/N] → execute
+> /scaffold                  # [y/N] → write the AGENTS.md layer
+> /undo                      # list journals, dry-run, execute
+```
+
+Readline history persists at `~/.local/state/slopkeeper/history` (arrows,
+Ctrl-W and friends all work), and **Tab completes**: command names,
+filesystem paths one component at a time (`/cat docs/can` → tab →
+`/cat docs/canonical.md`), and move/journal numbers.
+
+`/load <plan.json>` brings in a plan your agent wrote so you can review it
+move by move. First-tend authoring (naming a taxonomy from a full
+inventory) is agent work — point your agent at AGENT_GUIDE.md.
+
+## Design notes
+
+- The hard parts of corpus organization are *judgment* (the agent's),
+  *reference integrity* (grep-before-move, baked into validate/apply),
+  and *the human gate* (rendered markdown of every move with reasons and
+  risks). The tool makes the gate cheap; it does not try to remove it.
+- Fingerprint gating means a plan can never act on a corpus it wasn't
+  written against — the "silent drift" failure mode is closed.
+- Journals are JSONL with sha256s; undo is exact and reversible, and
+  prune empty dirs it created. Nothing is ever deleted.
+- Strategies are JSON rubric packs, not code: the agent reads them like
+  documentation, and new strategies are new files, not releases.
+
+## License
+
+MIT.

slopkeeper-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+# SPDX-FileCopyrightText: 2026 Greg Brandt <brandt.greg@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "slopkeeper"
+version = "0.1.0"
+description = "A SlopKeeper for agent-slop corpora. Inventory, partition and scaffold messy file corpora into agent-navigable folder-bots. Agent-first CLI: JSON envelope, next-step hints, hard safety gates."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Greg Brandt" }]
+keywords = ["agent", "corpus", "organization", "cli"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Utilities",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/brandtg/slopkeeper"
+Repository = "https://github.com/brandtg/slopkeeper"
+Issues = "https://github.com/brandtg/slopkeeper/issues"
+
+[project.scripts]
+slopkeeper = "slopkeeper.cli:main"
+
+[dependency-groups]
+# Dev-only tooling. Zero-dep is a RUNTIME rule: these ride in via
+# `uv sync --group dev` and never touch the project's runtime dependencies.
+dev = [
+  "mkdocs-material>=9.5",
+  "pytest>=8.0.0",
+  "pytest-cov>=6.1.1",
+  "reuse>=5.0.2",
+  "ruff>=0.9.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+slopkeeper = ["strategies/*.json", "AGENT_GUIDE.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+# Minimal gate: errors + pyflakes. Style policing is not the point;
+# undefined names and unused imports are. Dev-only: rides in the `dev`
+# dependency-group, never a runtime dependency.
+select = ["E", "F"]

slopkeeper-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+