code-jig 0.12.0__py3-none-any.whl

code_jig-0.12.0.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: code-jig
+Version: 0.12.0
+Summary: Personal harness core for Codex and Claude Code
+Project-URL: Source, https://github.com/jeancarlos/code-jig
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# code-jig
+
+[![CI](https://github.com/jeancarlos/code-jig/actions/workflows/ci.yml/badge.svg)](https://github.com/jeancarlos/code-jig/actions/workflows/ci.yml)
+[![security](https://github.com/jeancarlos/code-jig/actions/workflows/security.yml/badge.svg)](https://github.com/jeancarlos/code-jig/actions/workflows/security.yml)
+[![coverage](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/jeancarlos/code-jig/badges/coverage.json)](https://github.com/jeancarlos/code-jig/actions/workflows/ci.yml)
+[![release](https://img.shields.io/github/v/release/jeancarlos/code-jig)](https://github.com/jeancarlos/code-jig/releases/latest)
+[![license](https://img.shields.io/github/license/jeancarlos/code-jig)](LICENSE)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/jeancarlos/code-jig/badge)](https://scorecard.dev/viewer/?uri=github.com/jeancarlos/code-jig)
+![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)
+![platforms](https://img.shields.io/badge/platforms-Linux%20%7C%20macOS%20%7C%20Windows-lightgrey)
+![dependencies: none (stdlib)](https://img.shields.io/badge/dependencies-none%20(stdlib)-brightgreen)
+
+**Make the official Codex CLI cheaper, safer and smarter, by configuration alone.**
+
+code-jig is an open-source config pack for [OpenAI Codex](https://github.com/openai/codex). One command turns a stock install into a tuned setup: model tiers, automatic command review, a local token tracker, a set of battle-tested skills and a knowledge base that grows with you. No proxy, no daemon, no fork, no extra binaries. Just Python's standard library and the settings Codex already ships.
+
+## Why I built it
+
+I use coding agents every day, and I kept running into the same four problems.
+
+**1. Tokens disappear and nobody can say where.** Input, not output, is the bill: every request re-sends the whole conversation. I wanted to see exactly where it goes (which sessions, which commands, how much the safety reviews cost) without sending a byte to anyone. So code-jig reads Codex's own session files into a local SQLite database after every turn. Its totals match Codex's own per-thread count and [ccusage](https://github.com/ryoppippi/ccusage) to the token.
+
+**2. Safety that asks you a hundred times a day gets switched off.** Codex ships Guardian, a reviewer model that approves or denies commands leaving the sandbox. code-jig turns it on in every tier and lets you *add* local policy on top of the upstream rules instead of replacing them. You stay protected, and you stop clicking "approve".
+
+**3. Tips are cheap, measurements are not.** Every choice here was tested on a real bench before it shipped, and some popular ideas did not survive. An output-compression layer I used to swear by turned out to save little; Codex's own `tool_output_token_limit` already covered what mattered, so it went. One Guardian review costs about 7,000 input tokens on the bench, 84% of them cached, so I know what safety costs instead of guessing.
+
+**4. A setup should get better with use, and travel.** Lessons learned on a laptop usually die in that laptop's shell history. Here they become rules, Guardian policy, skills or knowledge facts in a small **overlay**, reviewed like code. The shared **core** stays clean and versioned; every machine gets its own overlay; nothing private ever flows back into the core.
+
+## What you get
+
+- **Tiers**: `default`, `deep`, `bulk`, `review`, each a generated Codex profile with its own model and reasoning effort. Pick the right brain for the job; [daily use](docs/runbooks/daily-use.md#which-model-for-which-job) maps jobs and skills to models for a public and an enterprise catalog.
+- **Cheap subagents**: an `explorer` role on the `bulk` model answers lookups with line ranges instead of file dumps, a `reviewer` role on the `review` model attacks plans and findings, and a `judge` role on the `deep` model decides disputes. Code-writing subagents keep the session's model.
+- **Guardian everywhere**, with your additions layered on the upstream policy.
+- **Token tracker**: `code-jig tokens` shows input, cache hit, Guardian share, escalated commands, the heaviest sessions and per-model usage. All local.
+- **Evidence**: `code-jig evidence` compares commits made in Codex sessions with the same repos' other commits (rework, `analyze` findings) and reports test runs, skill use, Guardian decisions and cost. Local data only.
+- **Cross-family review**: `code-jig cross-review` sends your diff to a model from another family, read-only, before you push.
+- **Sonar-style analysis without a server**: `code-jig analyze` runs the analyzers you already have (lizard, ruff, vulture, mypy, eslint with sonarjs, knip, tsc, dotnet build with SonarAnalyzer and NuGet audit, semgrep, gitleaks, osv-scanner) and groups the findings like Sonar: security, secrets, dependencies, bugs, types, unused code, complexity, duplication.
+- **Requirement tracing**: `code-jig trace` checks which requirement IDs (from Azure DevOps, GitHub issues or a Markdown design) have tests, and which tests cite IDs that no longer exist.
+- **Skills**: `cross-review`, `grilling` (stress-test a decision), `web-consensus` (settle facts against live sources), `improve` (turn a lesson into a durable change), and the deterministic toolbox: `code-analysis`, `regression-tests`, `hld-trace`, `bug-hunt` (property tests, fuzzing, mutation testing), `codegen` (OpenAPI clients, codemods) and `skill-validate`. Plus [superpowers](https://github.com/obra/superpowers) in one command.
+- **Knowledge base**: one fact per file, indexed, pointed at by the generated AGENTS.md.
+- **Sourced research**: `web-consensus` runs researchers, challenger and judge on the model each job needs, and `code-jig check-sources` confirms every quoted sentence is really on the cited page.
+- **No AI attribution, no unreviewed prose**: an opt-in git gate strips AI co-author lines from commit messages, removes invisible characters from staged files, refuses agent-written docs until you commit them yourself, cleans attribution from the commits you are about to push (then asks you to push again), and refuses pushes that fail your test command.
+- **Skills proven on Codex**: `code-jig lint-skill` and the `skill-validate` skill check a skill's text; `code-jig skill-check --review --live` has Codex review it and run its test cases, and CI refuses a skill whose stamp is not current.
+- **Edit feedback**: after every agent write, syntax errors and undefined names in Python, JSON and TOML, and a notice when a test is deleted or skipped, go straight back to the model. Nothing blocks.
+- **Doctor**: checks the binary, the pins, every tier's model against your account's catalog, the subagent roles, managed requirements, the AGENTS.md budget and the size of the skills list sent with every request, and probes each tier for free.
+- **Works on locked-down machines**: native Windows support, no scripts required, respects administrator-managed Codex config and tells you how it differs from what was tested.
+
+## Quick start
+
+Requires Python 3.11+ and git. Your overlay is a folder or git repository with an `overlay.toml`; see [personalizing](docs/personalizing.md). With no overlay, the installer makes `~/code-jig-overlay` for you.
+
+### From a release (no git checkout)
+
+<!-- install:start -->
+Latest release: **v0.12.0**. Everything downloads from GitHub. Copy a block as it is; it runs without edits.
+
+Linux and macOS:
+
+```sh
+curl -fsSL https://github.com/jeancarlos/code-jig/releases/download/v0.12.0/bootstrap.py | python3 -I -
+```
+
+Windows (PowerShell):
+
+```powershell
+irm https://github.com/jeancarlos/code-jig/releases/download/v0.12.0/bootstrap.py -OutFile bootstrap.py
+py -3 -I bootstrap.py
+```
+
+To use your own overlay instead of the default `~/code-jig-overlay`, add `--overlay` and its folder or git URL at the end of the `python3`/`py` line, for example `--overlay ~/my-overlay`.
+
+A piped script cannot check itself. To read what you run, download only `bootstrap.py`, read it, then run it:
+
+```sh
+curl -fsSL -o bootstrap.py https://github.com/jeancarlos/code-jig/releases/download/v0.12.0/bootstrap.py
+python3 -I bootstrap.py
+```
+
+`bootstrap.py` has no checksum of its own; reading it is the check. The bootstrap downloads the zip itself and checks it against the release's `SHA256SUMS`. That catches a corrupted download, but not a compromised GitHub release. Releases before v0.11.0 have no zip.
+
+**No one-liner allowed?** On a machine that blocks the download or PATH edits, download `code-jig.zip`, `SHA256SUMS` and `bootstrap.py` from the [v0.12.0 release page](https://github.com/jeancarlos/code-jig/releases/tag/v0.12.0) into one folder and run `py -3 -I bootstrap.py --zip code-jig.zip` there (`python3 -I` on Linux and macOS). The launcher does not need to be on PATH: the generated `AGENTS.md` tells agents its full path.
+<!-- install:end -->
+
+The bootstrap unpacks the release into `~/.local/share/code-jig/vX.Y.Z/` (`%LOCALAPPDATA%\code-jig\vX.Y.Z\` on Windows), runs `install`, writes `code-jig` and `cjig` launchers in `~/.local/bin` and runs `doctor`. The overlay's `core_version` picks the release. To change it, edit `core_version` and run the bootstrap again; see [upgrade and rollback](docs/runbooks/upgrade-and-rollback.md).
+
+### From a checkout (to change the core)
+
+```sh
+git clone https://github.com/jeancarlos/code-jig
+cp -r code-jig/overlay-examples/personal ~/code-jig-overlay   # your overlay
+export CODE_JIG_OVERLAY=~/code-jig-overlay
+cd code-jig
+./install.sh                                  # Windows: py -3 -m codejig install
+PYTHONPATH=. python3 -m codejig doctor
+codex --profile default
+```
+
+Edit `~/code-jig-overlay/profiles.toml` to pick your models; `doctor` lists the ones your account can use.
+
+### What the install counts
+
+The tool sends nothing. The download site counts requests for `bootstrap.py` and for release zips, and stores the event, the version, the client type (curl, PowerShell, Python or other) and the country. It does not store your IP address, your user-agent string or any install ID. The counts are request counts, not installs. See [ADR 0027](docs/adr/0027-install-from-a-release-url.md).
+
+**Prefer pipx?** `pipx install code-jig` installs the same release files as a wheel from PyPI, published from CI with Trusted Publishing and a PyPI attestation. Pick the overlay with `--overlay` and run `code-jig install` and `code-jig doctor`; `core_version` must match the installed version, and `pipx install code-jig==X.Y.Z` pins it. The first PyPI release is v0.12.0.
+
+## Documentation
+
+| Read | When |
+|---|---|
+| [Daily use](docs/runbooks/daily-use.md) | Tiers, skills, reviews, the repo's own AGENTS.md |
+| [Doctor](docs/runbooks/doctor.md) | What every check means and how to fix it |
+| [Tokens](docs/runbooks/tokens.md) | Reading the usage report |
+| [Evidence](docs/runbooks/evidence.md) | Whether code-jig pays off: rework, tests, skills, cost |
+| [Code quality](docs/runbooks/code-quality.md) | `analyze`, `trace`, the toolbox skills, installing the tools |
+| [Managed machines](docs/runbooks/managed-machine.md) | Installing where someone else administers the machine |
+| [Network and certificates](docs/runbooks/network-and-certificates.md) | TLS-inspecting networks, git and CLI tools in the sandbox |
+| [Circuit breaker](docs/runbooks/circuit-breaker.md) | When Guardian stops a turn |
+| [Commit attribution](docs/runbooks/commit-attribution.md) | Codex's co-author trailer and how to turn it off |
+| [Watermarks, humanizing and edit feedback](docs/runbooks/watermark-and-humanize.md) | What the write hook strips from agent output, what it reports back to the model, and how to run or disable it |
+| [Upgrade and rollback](docs/runbooks/upgrade-and-rollback.md) | Updates, rollbacks, uninstalling |
+| [Personalizing](docs/personalizing.md) | Overlay slots, pinning, the clean-room rule |
+| [Decisions](docs/adr/) | Why each design choice was made, and what was rejected |
+| [Contributing](CONTRIBUTING.md) | Code rules and tests |
+| [Editing the deck](docs/deck/README.md) | The presentation and its data files |
+
+## Principles
+
+- **Configuration, not interception.** code-jig writes files Codex reads. It never sits between you and the model.
+- **Measure, then decide.** Bench data in the repo, never guesses.
+- **Additive safety.** Local policy extends upstream policy; it never replaces it.
+- **Clean-room overlays.** Private context stays in private overlays. The core carries only what anyone could use.
+
+## Verify a release
+
+Every release asset has a Sigstore bundle (`<asset>.sigstore.json`), a SLSA build provenance file (`code-jig.intoto.jsonl`) and an SPDX SBOM (`code-jig.spdx.json`). Verify with:
+
+```
+gh attestation verify code-jig.zip --repo jeancarlos/code-jig
+cosign verify-blob code-jig.zip --bundle code-jig.zip.sigstore.json --certificate-identity-regexp '^https://github.com/jeancarlos/code-jig/' --certificate-oidc-issuer https://token.actions.githubusercontent.com
+```
+
+## License
+
+Apache-2.0.

code_jig-0.12.0.dist-info/RECORD

@@ -0,0 +1,52 @@
+codejig/__init__.py,sha256=oFXJ29j3C1ptyR4srl_tl-0-F7jzcbzJxfN7qHOHwv0,19
+codejig/__main__.py,sha256=9uMApG4EwjhSPByD35-l1PnTpHcqGydtTjXap8t_4uw,3895
+codejig/analyze.py,sha256=tcCsPI48tpd6QGbAjSVDuybwxVSdyolj3yDKULc11po,22361
+codejig/atomicwrite.py,sha256=ZYbujtL-Z-GDEmHdigtbglFmpOnrrCl06ftqDVE4zfs,1792
+codejig/collect.py,sha256=TjwTeNRklihGK9reFyFwmkIr44t3BbLS_w21xLSPMnw,12870
+codejig/doctor.py,sha256=McJp0dRuOKswbvfuAURVJO0WACdszTPBONeoIMO9fLg,15626
+codejig/evidence.py,sha256=h919W8OQz3tWtjt84KmNJWeI5c0UmDF03yptaWTRA_w,17082
+codejig/feedback.py,sha256=8ioe5xRyI5PF0nB2EY3cQbP4o-0xGUi0CYaQzODrOgI,5980
+codejig/gitgate.py,sha256=dbRf5oPhecU3sjaQR7EFdc68C2gdoVKYh7jhBkJMQmM,11460
+codejig/hooks.py,sha256=bF6SvwKJorX4uzZz8JLhSkm8Hj08YhTyN5A-IazlDHA,2422
+codejig/humanize.py,sha256=_qa29ilrucGECb7c8leCZUjBqkdE98SMWrP0DX3BQys,6472
+codejig/install.py,sha256=5fg8vmNLr77uYljioIRVM4FFy61KHfpFDa9mgvaU_BE,16124
+codejig/managed.py,sha256=JMK5GzQER8hSdbBj_Ml3NaKGkN_PI5u5ytU-OtJy4Kg,3006
+codejig/migrate.py,sha256=shuk4Cm27TPiR2zDavwLoF_8l7CDDqwMTyyCLG1LyFQ,19430
+codejig/overlay.py,sha256=jYR_AgErdFLO1-L_mzk4g-i0_SflSAp1xyTcCDY0ltA,1655
+codejig/paths.py,sha256=jBkb-VDsoXmppdiYsf8n5bobi9gDLNihC6OZUCBM7aE,1270
+codejig/probe.py,sha256=0oBBOa90iU6poFz6q3c2QFYIdYY3jlVoGGTuU8MNBKs,6020
+codejig/review.py,sha256=-CjXPhYJcnUUDL9kuw5KOlE6_qf2HJH9cJWKIBYsLl8,3323
+codejig/scrub.py,sha256=Lg2DLrmCIqlY3ErOe1y70p7gKSfpw8t-wVPSRfw0npo,10619
+codejig/skillcheck.py,sha256=k08ZSEFhMhs4m-VmRd3YI3iyn0YbgztxKhIfIfRGbNY,19222
+codejig/skilllint.py,sha256=tUFNGlTdtSiySOiDlnLgqFpD8jH5OpvbJG3iWPRi16E,4257
+codejig/sources.py,sha256=Eh3bIXUxHfjYVn19NBDVgj__W3VzpvYFeOSI-9opSko,8576
+codejig/tiers.py,sha256=2hE9_aG9hxx3uyPc56HnroV96H7AkhksNQ2LVX8rPBY,2162
+codejig/tokens.py,sha256=6WBrDG7nBwh9QGqcI92FtmUsoX_4wtj2fwrkYR6eCmI,5313
+codejig/trace.py,sha256=ijw2bxjpFRVocc0XGrkUiWd4KGcj7YK2Ztugf3ihAVQ,4879
+codejig/watermark.py,sha256=Qbe2QXPvmMsfxzPvRvf0CKh43LXU5mbL8W-OoWArurE,5020
+codejig/_core/VERSION,sha256=t7HtzNCbro8KktA0YpR4NFTGF-OFvEMjHz6O7GUDZM8,73
+codejig/_core/bench/requirements.toml,sha256=7OqsLeLDvcvI9Lk3q2e06iW4M7GhREiSoXEdJ_LP8T0,203
+codejig/_core/core/AGENTS.core.md,sha256=OjenxuZiO0e6L_3y91cMxFJrgkFBJ_2D7b1WDuP7WKQ,1510
+codejig/_core/core/tiers.toml,sha256=Pr2qyqI_5sOnpxvaJOjkVQJJR8XHxZkUqEKHo4qbbXE,62
+codejig/_core/core/agents/explorer.toml,sha256=AFVWPqy9fstEvdxYQ2qfZySut5l-Ffn19j7mniBetPg,1439
+codejig/_core/core/agents/judge.toml,sha256=RDFd4KgIh0XGWDDcFFXD6PoSJ_T6-5qYrMgGRRff6dY,1051
+codejig/_core/core/agents/reviewer.toml,sha256=caolxqS4cuCT7oVqNMCcwoor7qz1x1qvGXehiSe5-ew,728
+codejig/_core/skills/bug-hunt/SKILL.md,sha256=M3DfVUn8PBv21g0T1DRC4lFze2TKWS-Ut-Ur_GjSFEU,10470
+codejig/_core/skills/code-analysis/SKILL.md,sha256=VUTuNkAFXimmAfHyX8nqE5TS6QVy7AU7DhhLpJ7mX2k,5972
+codejig/_core/skills/codegen/SKILL.md,sha256=chXoMeY5lGPPoW5qZ0_F37mh3XHJOJmCDukjOPLHZVQ,2789
+codejig/_core/skills/cross-review/SKILL.md,sha256=N20NaHzIGLxORc16YthdkedlcFilFDu5sPI1eENbP1g,1678
+codejig/_core/skills/grilling/SKILL.md,sha256=1ck-o6nM8eU2SkVwLNTX9wXtA3Pr1qbB2eW0pLJ2YQM,3220
+codejig/_core/skills/hld-trace/SKILL.md,sha256=VCgrmblWlPM-2wHL1CoCRo_CREFAFl4j043Yg-yrdag,4847
+codejig/_core/skills/improve/SKILL.md,sha256=_gTcDsyHt3RwFF0W9q3q5JSLHg8EQNdGPy6uiniFKRU,2346
+codejig/_core/skills/redacao/SKILL.md,sha256=B1UZLJ7CE5-jDmfR53rQxQzdptG9SqWrSiBdswBE-rg,9776
+codejig/_core/skills/redacao/checar.py,sha256=8ysAFXU1bLbI9iUyWFuflM7JeblfhAv4f4gwwtpngEE,2966
+codejig/_core/skills/redacao/reference.md,sha256=2kLfx4XH6YmRdXU07DKOA5P8GbmMBDv5l-JVwmcUk44,9775
+codejig/_core/skills/regression-tests/SKILL.md,sha256=SQFEbVwWprf2tmOJjYtF2wuzvUmBuKrbmjuHkIH1My8,2720
+codejig/_core/skills/remove-ai-attribution/SKILL.md,sha256=zlxhS6H30SGj6W4GzPso7MV1u_9UHvUyLs2Ldb18H9o,2981
+codejig/_core/skills/skill-validate/SKILL.md,sha256=0573vaSlkVqNbpINWo9OQuo_qbsvF77I7xw3I0HCVjc,3853
+codejig/_core/skills/web-consensus/SKILL.md,sha256=kgWcHEx53tRGLe7Ezmsmzmg_MWkF_3d0jnQPGwial-4,6351
+code_jig-0.12.0.dist-info/METADATA,sha256=OSc-R_DuXmyo88_-9YaeHuTimdsa8sltv2ZVMhaxSek,13314
+code_jig-0.12.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+code_jig-0.12.0.dist-info/entry_points.txt,sha256=hcZkHUw2L_IOmVHY822XmHfG0sFWE4iYvo02LSHevMA,51
+code_jig-0.12.0.dist-info/licenses/LICENSE,sha256=Ln2GpwCk-iWdsvheE5ZizciKqkCp6y_rl-4XvsAv5YY,11341
+code_jig-0.12.0.dist-info/RECORD,,

code_jig-0.12.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

code_jig-0.12.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+code-jig = codejig.__main__:main

code_jig-0.12.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Jean Souza
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

codejig/__init__.py

@@ -0,0 +1 @@
+VERSION = "0.12.0"

codejig/__main__.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import argparse
+import importlib
+import sys
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="code-jig")
+    p.add_argument("--overlay")
+    p.add_argument("--codex-home")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("install")
+    d = sub.add_parser("doctor")
+    d.add_argument("--codex-bin")
+    d.add_argument("--check-binary", action="store_true")
+    d.add_argument("--live", action="store_true")
+    c = sub.add_parser("collect")
+    c.add_argument("--rescan", action="store_true")
+    h = sub.add_parser("hooks")
+    h.add_argument("--hook-type", choices=["claude-code", "codex"], required=True)
+    h.add_argument("path", nargs="*")
+    hu = sub.add_parser("humanize")
+    hu.add_argument("path", nargs="*")
+    hu.add_argument("--check", action="store_true", help="dry-run: report changes without writing")
+    t = sub.add_parser("tokens")
+    t.add_argument("--days", type=int, default=7)
+    t.add_argument("--cache-floor", type=float, default=97.5)
+    t.add_argument("--top", type=int, default=10)
+    r = sub.add_parser("cross-review")
+    r.add_argument("--base")
+    r.add_argument("--profile", default="review")
+    r.add_argument("--codex-bin")
+    r.add_argument("files", nargs="*")
+    a = sub.add_parser("analyze")
+    a.add_argument("path", nargs="?", default=".")
+    a.add_argument("--base")
+    a.add_argument("--top", type=int, default=10)
+    a.add_argument("--json", action="store_true")
+    a.add_argument("--timeout", type=int, default=600)
+    tr = sub.add_parser("trace")
+    tr.add_argument("ids")
+    tr.add_argument("--path", default=".")
+    tr.add_argument("--pattern", default="REQ-{id}")
+    tr.add_argument("--json", action="store_true")
+    ev = sub.add_parser("evidence")
+    ev.add_argument("--days", type=int, default=90)
+    ev.add_argument("--repo")
+    ev.add_argument("--analyze", type=int, default=0)
+    ev.add_argument("--timeout", type=int, default=600)
+    ev.add_argument("--json", action="store_true")
+    ls = sub.add_parser("lint-skill")
+    ls.add_argument("path", nargs="*")
+    sc = sub.add_parser("scrub")
+    sc.add_argument("path", nargs="?", default=".")
+    sc.add_argument("--author", action="append", default=[])
+    sc.add_argument("--dry-run", action="store_true")
+    gh = sub.add_parser("git-hook")
+    gh.add_argument("name")
+    gh.add_argument("rest", nargs="*")
+    gh.add_argument("--prose", action="store_true")
+    gh.add_argument("--cleanup", action="store_true")
+    sk = sub.add_parser("skill-check")
+    sk.add_argument("skills", nargs="+")
+    sk.add_argument("--review", action="store_true")
+    sk.add_argument("--live", action="store_true")
+    sk.add_argument("--profile", default="default")
+    sk.add_argument("--codex-bin")
+    sk.add_argument("--trust-evals", action="store_true")
+    cs = sub.add_parser("check-sources")
+    cs.add_argument("files", nargs="+")
+    mg = sub.add_parser("migrate")
+    mg.add_argument("--dry-run", action="store_true")
+    mg.add_argument("repos", nargs="*")
+    return p
+
+
+COMMAND_MODULES = {
+    "install": "install",
+    "collect": "collect",
+    "tokens": "tokens",
+    "cross-review": "review",
+    "analyze": "analyze",
+    "trace": "trace",
+    "evidence": "evidence",
+    "hooks": "hooks",
+    "humanize": "humanize",
+    "lint-skill": "skilllint",
+    "scrub": "scrub",
+    "git-hook": "gitgate",
+    "skill-check": "skillcheck",
+    "check-sources": "sources",
+    "migrate": "migrate",
+}
+
+
+def main(argv: list[str] | None = None) -> int:
+    if sys.version_info < (3, 11):
+        print("code-jig: Python 3.11 or newer is required", file=sys.stderr)
+        return 2
+    args = build_parser().parse_args(argv)
+    return importlib.import_module(f"codejig.{COMMAND_MODULES.get(args.cmd, 'doctor')}").cli(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

codejig/_core/VERSION

@@ -0,0 +1,2 @@
+v0.12.0
+2fab5fa59ef304350c13b21e599093037f18e73bb97d9b583bc338ee2c67b70b

codejig/_core/bench/requirements.toml

@@ -0,0 +1,4 @@
+allowed_approval_policies = ["untrusted", "on-request"]
+allowed_approvals_reviewers = ["user", "auto_review"]
+allowed_sandbox_modes = ["read-only", "workspace-write"]
+check_for_update_on_startup = false

codejig/_core/core/AGENTS.core.md

@@ -0,0 +1,9 @@
+# code-jig core rules
+
+- One thread per task. When the topic changes, finish and start a new thread instead of continuing.
+- Deterministic first. Before reasoning about anything countable or checkable, run the `code-jig` command or script that answers it.
+- No polling loops. Do not chain `sleep`/`wait` calls when one blocking command or a single check gives the answer.
+- Minimal code. Reuse what exists, prefer the standard library, delete before adding, no speculative abstractions.
+- Root cause over symptom. Fix the shared function, not each caller.
+- No AI attribution. Never write `Co-authored-by` or `Generated with` lines for an AI, `AI-assisted` notes or robot emoji in commits, pull requests, comments or files. If one already reached history, use the `remove-ai-attribution` skill.
+- Subagent check. Before each `spawn_agent`, decide whether the job needs one and which `agent_type` fits. Skip it for one grep, one file read or a few commands: do those yourself. `explorer` (bulk tier) for lookups, `worker` for one bounded change with a clear file scope, checked before the next, `reviewer` (review tier) to attack a plan, diff or claim before acting on it, `judge` (deep tier) to decide between gathered conflicting claims, `default` for any other self-contained task. Keep architecture, subtle multi-file logic, security and root-cause debugging in the main thread, and say so when they need the deep tier. At most three in parallel unless asked. Name the agent you picked and why in one line.

codejig/_core/core/agents/explorer.toml

@@ -0,0 +1,24 @@
+name = "explorer"
+description = """
+Use `explorer` for lookups: where something is defined or used, what a file, doc or command output says, what a web source says.
+It runs on the bulk tier, a fast and cheap model, and returns paths with line ranges instead of file contents.
+- Give it a self-contained question with the paths or names it needs, and do not fork your history into it (`fork_turns`): a forked explorer re-reads the whole conversation.
+- Spawn several in parallel for independent questions, and keep working while they run.
+- Trust their answers unless a fact is load-bearing; then read the lines they cite yourself.
+- It costs a full request of its own; for one grep or one file read, run it yourself.
+- Never use it to write or change code."""
+developer_instructions = """
+You are an explorer. Answer the one question you were given, and only that question.
+- Read files, search, and run commands that change nothing. Use web search only for facts outside the repository.
+- Never edit files, install anything, or run commands that change state.
+- Answer with what you found: `path:start-end` line ranges with a one-line fact each, and for web facts the URL with a short exact quote.
+- Never paste whole files or long command output. Quote at most the few lines that prove a point.
+- Say what you could not find, then stop."""
+
+[skills]
+include_instructions = false
+
+[features]
+apps = false
+plugins = false
+memories = false

codejig/_core/core/agents/judge.toml

@@ -0,0 +1,19 @@
+name = "judge"
+description = """
+Use `judge` to decide between conflicting claims, findings or options when the material is already gathered: a web-consensus verdict, competing fixes, a disputed review finding.
+It runs on the deep tier, the strongest model, and decides from the material it is given.
+Give it the question and every piece of evidence it should weigh, including what the other side said. It does not search or edit."""
+developer_instructions = """
+You are a judge. Decide the question you were given from the material you were given, and nothing else.
+- Do not search, browse or run commands that fetch anything new. If the material cannot settle a point, say so and name the evidence that would.
+- Weigh sources, not voices: a claim stands on its cited evidence, not on who argued it, how often, or how confidently.
+- Give the decision first, then for each point: what decides it, the source, and how sure you are.
+- Never edit files."""
+
+[skills]
+include_instructions = false
+
+[features]
+apps = false
+plugins = false
+memories = false

codejig/_core/core/agents/reviewer.toml

@@ -0,0 +1,10 @@
+name = "reviewer"
+description = """
+Use `reviewer` to attack a plan, diff, finding or claim before acting on it.
+It runs on the review tier, a different model family, and looks for what is wrong, not for what is right.
+Give it the material and the claim to check. It does not edit."""
+developer_instructions = """
+You are a reviewer from a different model family. Find what is wrong with the material you were given: bugs, false claims, missing cases, unsafe steps.
+- Check every claim against the files, commands or sources you can read. Never edit anything.
+- Report each problem as: location, what is wrong, the evidence, and how sure you are.
+- Report nothing you cannot support. If you find nothing, say so in one line."""

codejig/_core/core/tiers.toml

@@ -0,0 +1,4 @@
+default = "medium"
+deep = "high"
+bulk = "low"
+review = "high"