Change: relicense the Engine to plain Apache-2.0

[StarshipSuperjam]

Closes #635

A green mechanical check below shows this change conforms to the engine's rules — not that it is correct. What covers correctness is the behavioural steps in Review and your own read of the change; a green check is never a substitute for that. Your merge is the binding gate.

About those checks: only the one that runs when the change is proposed for merge can stop a risky merge — a check that ran while the change was still being written is early advice. A check that could not run leaves its area unverified.

Purpose

Relicense the Engine from Apache-2.0 + Commons Clause to plain Apache-2.0 — drop the Commons Clause.

• The template shipped source-available under Apache-2.0 + the Commons Clause ("you may not Sell the Software"). As sole licensor, the maintainer decided that clause protects a resale scenario they would never enforce (a hobby project) and actively deters adoption — it is source-available, not OSI-approved, so GitHub displayed the repository's license as "Other" rather than a named license.
• This supersedes Engine fault: the Commons Clause may not bind an adopter without an .engine/-scoped NOTICE #635, which had asked to go the opposite way — strengthen the clause by adding an .engine/-scoped NOTICE so the restriction would bind adopters. Working Engine fault: the Commons Clause may not bind an adopter without an .engine/-scoped NOTICE #635 surfaced the deeper call: an unenforced restriction that lowers adoption is pure cost, so the honest move is to drop it, not fortify it.

Impact: the Engine now presents as a trusted, permissive Apache-2.0 project — GitHub shows a named "Apache-2.0" — with no restriction the maintainer never intended to defend.

Scope

A plain-Apache-2.0 seed appended to the license recognizer, the root LICENSE and README reconciled to match, and the tests re-anchored.

• .engine/tools/license_seeds.py: the current shipped seed is now plain Apache-2.0. It is derived from the retired seed's own Apache body (split at the 75-dash rule) so the license text is byte-identical to what shipped before — no retyping — with the Commons Clause header replaced by a single copyright-form holder line, Copyright 2026 StarshipSuperjam - The Engine (engine-template). The seed set is appended, not replaced: HISTORICAL_SEEDS = (retired Apache+Commons-Clause seed, new plain-Apache seed), so any repo generated from the template before this merge still recognizes its lingering Commons Clause LICENSE.
• Root LICENSE: rewritten, byte-identical to the new CURRENT_SEED (bound by the parity test); Commons Clause header gone; a Copyright 2026 StarshipSuperjam holder line retained.
• README.md: the license badge and License section flip from "Source-available (Apache-2.0 + Commons Clause) … not OSI-approved … no right to Sell" to permissive Apache-2.0.
• .engine/tools/instantiator.py: comments only — it aliases the seed/recognizer, no logic change.
• Tests re-anchored (not inverted): the guards that used to key on the Commons Clause now key on the holder line, so an adopter's own Apache-2.0 is still provably preserved.

Change profile — the shape of this pull request at a glance:

• Size: 7 files changed, +101 / −76 lines.
• Kinds of thing touched: 4 tools, 3 other files (not in the engine's map).
• Where: .engine/tools, .engine/knowledge, LICENSE, README.md.
• Shape: 3 commits on this branch — a standalone change.

Impact: the recognizer, the root LICENSE, and the operator-facing copy all move together and stay in sync.

Behaviors

The Engine presents as permissive Apache-2.0, and the first-run clear still deletes only the Engine's own license, never an adopter's.

• A freshly generated repo carries no Commons Clause; GitHub detects the LICENSE as Apache-2.0 (confirmed live via gh api …/license → spdx_id: Apache-2.0).
• The current plain-Apache seed is recognized (so first-run still clears the traveled template license) — test_current_seed_is_plain_apache_without_commons_clause, test_matches_every_historical_seed.
• Stock Apache-2.0 without the holder line is preserved (never deleted) — test_stock_apache_without_the_holder_line_is_preserved (the red tripwire) and test_the_apache_body_without_the_holder_line_is_not_matched; a different/renamed holder is preserved — test_stock_apache_with_a_different_holder_is_preserved, test_a_renamed_holder_is_preserved_never_deleted.
• The retired Commons Clause seed is still recognized (pre-merge repos aren't orphaned) — test_carries_two_members_after_the_apache_relicense; the root LICENSE stays byte-identical to the seed — TestRepoLicenseIsTheTemplateSeed.

Out of scope

The design-record corpus edit, a README-content test guard, and the copyright-line phrasing.

• The decision records that this reverses (D-295) or whose premises it shifts (D-301/D-302) live in the separate, currently-parked engine-mechanic design corpus. Per the standing preference not to gate an engine-template build on a paired design-corpus edit, that update is a tracked follow-up: engine-mechanic Engine health: A concern raised while working wasn't given a disposition before the turn ended, so the engine logged it he... #54 — this PR carries the interim record (see Risk).
• The README license badge/section has no mechanical parity guard (a pre-existing gap, not introduced here) — left as a possible future improvement rather than adding a brittle prose-matching test.
• The holder line reads slightly unusually for a legal document (Copyright 2026 StarshipSuperjam - The Engine (engine-template)) — deliberate: it is the machine-readable delete-safety anchor, and it is copyright-form so GitHub's Licensee strips it before detecting Apache-2.0.

Impact: these are bounded, disclosed choices — the smallest change that fully delivers the outcome — not gaps.

Risk

This narrows the delete-safety discriminator, and the automated guardrail can't see it — so the disclosure is manual; the relicense itself is forward-only and legally clean.

• Delete-safety discriminator narrowed — disclosed because the guard is blind to it. The first-run clear (instantiator._seed_license) deletes a root LICENSE that the recognizer matches, and the boot detector offers to remove one. Dropping the Commons Clause narrows the sole discriminator between "the Engine's own traveled license" and "an adopter's own Apache-2.0" from the entire distinctive Commons Clause block down to the one holder line. This was adversarially tested: three independent reviews ran the recognizer against real adopter-shaped Apache licenses (stock GitHub-picker output, filled appendix, renamed holder, year-bumped, case-folded, whitespace variants) and none matched — preserve-on-doubt is intact (an adopter's own Apache differs in two independent places: no holder line and an unfilled appendix placeholder). The engine's guardrail-weakening check does not and cannot flag this class of change — it watches a check's wrapper script, not the imported library where this logic lives (the known blind spot, engine-template#895) — so no guardrail-ack fired. Do not read "no ack" as "nothing changed here": this is a real narrowing of a deletion mechanism, disclosed manually and reviewed on its merits.
• Forward-only relicense, legally clean. Relicensing to a more permissive license is a one-way door (already-distributed copies keep their terms), but it needs no contributor consent: the sole copyright holder is relaxing a restriction they alone added (git history shows only the maintainer as human author). Nothing already distributed is affected.
• Governance record. This reverses D-295 (which added the Commons Clause), makes D-301's reserved .engine/ NOTICE hedge moot (no restriction remains to bind), and shifts D-302's recognizer anchor from the Commons Clause licensor field to the holder line (a shape D-302's design already supported). Engine fault: the Commons Clause may not bind an adopter without an .engine/-scoped NOTICE #635 is superseded — closed in the direction opposite to what it originally asked. The design-corpus update is tracked as engine-mechanic Engine health: A concern raised while working wasn't given a disposition before the turn ended, so the engine logged it he... #54.

Impact: the consequences are bounded, adversarially checked, and disclosed rather than silently shipped.

Validation

Full self-test and CI check-suite green on the final tree; recognizer safety independently re-verified by review; GitHub detection confirmed live.

• Local selftest.py PASSED (~5,000+ tests, 275s) on the reviewed tree; validate.py --suite CI passed with no hard findings; the license/instantiator/health suites are green (18 / 271 / 14). The knowledge-graph fingerprint check passes on the regenerated graph.json.
• GitHub's own Licensee detects the new LICENSE as Apache-2.0 — verified via gh api repos/StarshipSuperjam/engine-template/license?ref=<branch> → spdx_id: Apache-2.0. The README's "named Apache-2.0" claim is confirmed, not assumed.
• The Apache-2.0 body was read in full and matches canonical structure (Definitions through §9, END OF TERMS, Appendix) with no altered terms; the root LICENSE is byte-identical to license_seeds.CURRENT_SEED.
• Reconcile: the branch base is current with main (no rebase needed); the knowledge graph was regenerated from the final tree and matched a true regeneration; the self-map was unaffected. No work lost, no hand-merge.

Impact: an approver can rely on the behaviours above being exercised by committed tests, a live GitHub detection check, and a green full suite on the exact bytes proposed for merge.

Review

Reviewed to full (thorough) depth both before and after building; two gates, nine independent cold-context lenses, zero blocking findings.

• Before building (thorough plan review): four cold lenses (architecture, feasibility, product-intent, risk-governance, on Opus 4.8) reviewed the plan. They found the design sound and surfaced the one thing that matters — that dropping the clause makes the holder line load-bearing — and handed the elegant resolution (put the anchor in a copyright-form line so GitHub's Licensee strips it for detection while the recognizer keeps it in the raw text). No blocking design flaw; the operator chose the "plain Apache-2.0" target and the thorough depth.
• After building (thorough deliverable review): five cold lenses (spec-conformance, an adversarial divergence hunt, security-governance, technical-integrity, usability, on Sonnet 5) reviewed the built change. Several ran the changed recognizer in throwaway processes against adversarial adopter licenses. Zero blocking findings. Deletion-safety was independently confirmed clean by three lenses; the Apache body verified verbatim; the sole-licensor relicense confirmed legally clean. The two "serious" findings were process-shaped, not code defects — they required this PR body to (a) disclose the discriminator narrowing + guard blindness and (b) record the D-295 reversal / Engine fault: the Commons Clause may not bind an adopter without an .engine/-scoped NOTICE #635 supersession with a real filed follow-up; both are now done (see Risk; engine-mechanic Engine health: A concern raised while working wasn't given a disposition before the turn ended, so the engine logged it he... #54).
• Post-review fix — a minor touch-up, re-checked green. Technical-integrity flagged that the rename left some comments/docstrings saying "Licensor" beside the new "holder" vocabulary. I threaded the rename through (comment/name-only, no behavior). Between reviewed 8fa15a7 and submitted b4d053c, 8 lines were added and 8 deleted or modified, a net change of +0 lines across 3 files — a trivial cosmetic delta, so no re-audit was warranted; the scoped tests and CI suite were re-run green on the final tree.
• No unresolved blocking or serious findings remain.

Nothing here is something you can run yourself — there's no settled description for this project yet.

Offered checks you can run: view the repository's license on GitHub (it now reads Apache-2.0); read the new root LICENSE; or run the recognizer tests — uv run --directory .engine -- python -m unittest discover -s tools -p 'test_license_seeds.py' — the tripwire test proves a stock adopter Apache-2.0 is preserved.

Impact: two review gates and an adversarial recognizer probe found no blocking issue; your merge is the binding gate.

Files of interest

The recognizer seed and the license artifact carry the whole change.

• .engine/tools/license_seeds.py — the plain-Apache seed (derived byte-exact), the appended two-member set, and the docstring that marks the holder line as the load-bearing delete-safety anchor.
• LICENSE — the new plain Apache-2.0 (byte-identical to the seed).
• README.md — the license badge + section, now permissive Apache-2.0.
• .engine/tools/test_license_seeds.py / test_instantiator.py — the re-anchored preserve-on-doubt tripwires.

Impact: these determine whether the license is honest and whether the first-run clear can only ever delete the Engine's own license.

AI involvement

Claude Code (Opus 4.8) drove the design and implementation; the operator, as licensor, made the load-bearing call; cold-context AI reviews stress-tested the safety.

• The reframe from Engine fault: the Commons Clause may not bind an adopter without an .engine/-scoped NOTICE #635 ("strengthen the clause") to "drop it" came from a critical-thinking exchange; the operator decided to relicense and chose plain Apache-2.0. The seed design, the copyright-form anchor, and the append discipline were AI-proposed and pressure-tested by four plan-review lenses (Opus 4.8) before building and five deliverable lenses (Sonnet 5) after.
• The recognizer's safety (that an adopter's own Apache-2.0 is never deleted) was verified by AI reviews running the code against adversarial inputs, not by assertion.

Impact: AI judgment is load-bearing on the seed design and the safety argument; the operator decided the relicense and its target, and the merge is theirs.