repopact 2.0.0__tar.gz → 2.0.1__tar.gz

repopact-2.0.1/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: repopact
+Version: 2.0.1
+Summary: A repository-native standard for durable agent work: binding invariants, evidence-gated work items, and drift audits.
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/ForgeWireLabs/repopact
+Project-URL: Repository, https://github.com/ForgeWireLabs/repopact
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema>=4.20
+Dynamic: license-file
+
+# RepoPact
+
+RepoPact is a **repository-native governance kernel for durable agent work**. It keeps the
+load-bearing state of a project — intent, authority, evidence, decisions, and drift — as
+typed, version-controlled records in the filesystem, so a new contributor or agent can
+recover where things stand *without* a prior conversation, and so the guarantees that matter
+cannot be silently weakened.
+
+> The repository is the pact: authority, intent, evidence, and history that survive every
+> session.
+
+`pip install repopact` · Apache-2.0 · current release **2.0.1**
+([changelog](decisions/0021-preflight-mandatory-and-provenance.md)).
+
+## How it relates to `AGENTS.md`
+
+`AGENTS.md` (and `CLAUDE.md`, editor rules) tell an agent *what to do* — they're
+instructions, plain Markdown, with no enforcement. RepoPact is the layer **above** them:
+
+> `AGENTS.md` tells the agent what to do. RepoPact proves it didn't quietly undo it.
+
+RepoPact's distinguishing primitive is the **binding invariant** — a declared guarantee with
+a rationale, an escalation path, and (where its logical type permits) a machine enforcer.
+That, plus evidence-gated completion and a filesystem state machine, is what turns a folder
+convention into a contract. `repopact adopt` ingests an existing `AGENTS.md` rather than
+replacing it (decision [`0020`](decisions/0020-launch-positioning-layer-above-agents-md.md)).
+
+## Core loop
+
+```text
+intent -> scoped authority -> work item -> implementation -> evidence -> audit -> history
+```
+
+![RepoPact core loop over a filesystem state machine](docs/assets/repopact-flow.svg)
+
+## Primitives
+
+1. **Charter & invariants** — principles (judgment) and binding invariants
+   (escalation-gated) in `governance/`.
+2. **Frozen surface** — paths and symbols that require operator approval (`--ack`) to change.
+3. **Scopes & roles** — layered `AGENTS.md` contracts plus a role/scope map in
+   `governance/owners.json`.
+4. **Work items** — narrative `README.md` + machine-readable `work-item.json` with
+   evidence-linked acceptance criteria. **Mandatory preflight** (2.0): a work item must be
+   recorded *before* implementation begins (`repopact new` stamps the marker).
+5. **Evidence** — immutable run manifests under `evidence/runs/`.
+6. **Decisions & policies** — durable choices (`decisions/`) and operating rules
+   (`governance/policies/`) whose rationale outlives any single work item.
+7. **Provenance** (2.0) — every record is `concrete`, `provisional`, or `inferred`.
+   `adopt` emits provisional/inferred records (honest, not fabricated); `doctor` ratchets
+   them to `concrete` as real evidence arrives. See *2.0 changes* below.
+8. **Reconciliation** — audits and a *generated* dashboard surface drift and review
+   staleness rather than hand-maintaining it.
+
+## Install & quick start
+
+```powershell
+pip install repopact                # the CLI + reference validator, from PyPI
+repopact init --target ../your-repo # seed a valid RepoPact in a new repo
+cd ../your-repo
+repopact new work-item "Title of the work"   # stamps records (incl. the preflight marker)
+repopact validate
+repopact dashboard
+```
+
+`repopact` dispatches `init`, `adopt`, `validate`, `new`, `dashboard`, `spec`,
+`check-frozen`, `import-plan`, and `doctor`. Records are validated against `schemas/*.json`
+(structure) and by the validator (cross-record semantics; decision
+[`0003`](decisions/0003-validate-records-against-json-schemas.md)). Begin with
+[`AGENTS.md`](AGENTS.md), then [`governance/charter.md`](governance/charter.md) and
+[`governance/workflow.md`](governance/workflow.md).
+
+## Adopt an *existing* repository
+
+For a project that already has CODEOWNERS, CI workflows, and nested `AGENTS.md` contracts,
+`adopt` maps those existing signals into RepoPact records without overwriting anything:
+
+```powershell
+repopact adopt --target ../existing-repo --dry-run   # preview the plan, write nothing
+repopact adopt --target ../existing-repo             # create records, then validate
+repopact doctor                                      # diagnose + repair drift; migrate on upgrade
+```
+
+CODEOWNERS becomes scopes and roles; each `.github/workflows/*` becomes a binding-gate policy
+(plus invariant `INV-2` and a frozen-surface entry); every nested `AGENTS.md` is registered as
+a contract; git history seeds a first **inferred** evidence run, and the adoption record is
+recorded as **provisional** — honestly typed, not a fabricated "completed" claim. Adoption is
+idempotent.
+
+## 2.0: mandatory preflight + provenance-typed records
+
+Decision [`0021`](decisions/0021-preflight-mandatory-and-provenance.md) (supersedes 0018):
+
+- **Mandatory preflight (default on).** No work begins until a work item exists and
+  propagates through the pact; `repopact new` stamps the marker. Existing repos grandfather
+  their pre-2.0 items automatically — `adopt`/`init` set a preflight epoch and `doctor`
+  migrates on upgrade. *This is a breaking change*: run `repopact doctor` after upgrading.
+- **Provenance typing** (`concrete` / `provisional` / `inferred`, default `concrete`). This
+  is the principled escape from the *adoption trilemma*: `adopt` emits provisional/inferred
+  records so the result is both **valid** and **faithful** (reconstruction is labelled, not
+  faked). Completion still requires `concrete` evidence; `doctor` ratchets when it arrives.
+
+## Status is a filesystem transition
+
+Work moves between `work/active`, `work/blocked`, `work/deferred`, and `work/completed`; its
+`work-item.json` status must match its directory. Moving a work item never deletes its
+reasoning, decisions, or evidence links.
+
+## Derive over declare
+
+Anything computable from source records is generated, not authored by hand (the dashboard,
+audit-freshness views, and the derived blocks of `SPEC.md`). Only genuine sources are
+hand-maintained. See policy `001`.
+
+## Evaluation, formal model & the Proving Ground
+
+RepoPact is developed against its own evidence, not assertion. The `research/` lab notebook
+holds a [formal model](research/formal-model.md) (the L0–L5 kernel, the typed invariant
+lattice, the adoption trilemma), the pre-registered [experiment protocol](research/protocol.md)
+and [benchmark protocol](research/benchmark-protocol.md) (hypotheses H1–H13, falsification
+criteria, [threats to validity](research/threats-to-validity.md)), a [findings
+register](research/findings.md), and a full [paper draft](research/paper.md).
+
+**PactBench** — the runnable benchmark suite (pre-registered tasks measuring whether RepoPact
+enforcement reduces silent guarantee drift, with a model-agnostic harness and an S5 drift
+harness) — lives in the **[RepoPact Proving
+Ground](https://github.com/ForgeWireLabs/repopact-proving-ground)**, a throwaway-but-real
+project that consumes RepoPact from PyPI and is driven across every primitive, including cases
+designed to break it. RepoPact defines the *protocol* (`research/`); the Proving Ground hosts
+the runnable suite. *RepoPact defines the pact; the Proving Ground tests whether the pact
+holds under agent pressure.*
+
+## Ecosystem
+
+RepoPact is the work-governance layer of [ForgeWire Labs](https://github.com/ForgeWireLabs) —
+inspectable agentic infrastructure (*inspect the work, bound the authority, preserve the
+evidence*). It composes with Fabric (execution governance) and ForgeLink (human-agent
+communication governance), but is independently useful on its own.
+
+## License & version
+
+Apache-2.0 ([`LICENSE`](LICENSE), decision [`0002`](decisions/0002-license-apache-2.0.md)).
+The spec version is in [`VERSION`](VERSION); templates for every record type live in
+[`templates/`](templates/).

repopact-2.0.1/README.md

@@ -0,0 +1,144 @@
+# RepoPact
+
+RepoPact is a **repository-native governance kernel for durable agent work**. It keeps the
+load-bearing state of a project — intent, authority, evidence, decisions, and drift — as
+typed, version-controlled records in the filesystem, so a new contributor or agent can
+recover where things stand *without* a prior conversation, and so the guarantees that matter
+cannot be silently weakened.
+
+> The repository is the pact: authority, intent, evidence, and history that survive every
+> session.
+
+`pip install repopact` · Apache-2.0 · current release **2.0.1**
+([changelog](decisions/0021-preflight-mandatory-and-provenance.md)).
+
+## How it relates to `AGENTS.md`
+
+`AGENTS.md` (and `CLAUDE.md`, editor rules) tell an agent *what to do* — they're
+instructions, plain Markdown, with no enforcement. RepoPact is the layer **above** them:
+
+> `AGENTS.md` tells the agent what to do. RepoPact proves it didn't quietly undo it.
+
+RepoPact's distinguishing primitive is the **binding invariant** — a declared guarantee with
+a rationale, an escalation path, and (where its logical type permits) a machine enforcer.
+That, plus evidence-gated completion and a filesystem state machine, is what turns a folder
+convention into a contract. `repopact adopt` ingests an existing `AGENTS.md` rather than
+replacing it (decision [`0020`](decisions/0020-launch-positioning-layer-above-agents-md.md)).
+
+## Core loop
+
+```text
+intent -> scoped authority -> work item -> implementation -> evidence -> audit -> history
+```
+
+![RepoPact core loop over a filesystem state machine](docs/assets/repopact-flow.svg)
+
+## Primitives
+
+1. **Charter & invariants** — principles (judgment) and binding invariants
+   (escalation-gated) in `governance/`.
+2. **Frozen surface** — paths and symbols that require operator approval (`--ack`) to change.
+3. **Scopes & roles** — layered `AGENTS.md` contracts plus a role/scope map in
+   `governance/owners.json`.
+4. **Work items** — narrative `README.md` + machine-readable `work-item.json` with
+   evidence-linked acceptance criteria. **Mandatory preflight** (2.0): a work item must be
+   recorded *before* implementation begins (`repopact new` stamps the marker).
+5. **Evidence** — immutable run manifests under `evidence/runs/`.
+6. **Decisions & policies** — durable choices (`decisions/`) and operating rules
+   (`governance/policies/`) whose rationale outlives any single work item.
+7. **Provenance** (2.0) — every record is `concrete`, `provisional`, or `inferred`.
+   `adopt` emits provisional/inferred records (honest, not fabricated); `doctor` ratchets
+   them to `concrete` as real evidence arrives. See *2.0 changes* below.
+8. **Reconciliation** — audits and a *generated* dashboard surface drift and review
+   staleness rather than hand-maintaining it.
+
+## Install & quick start
+
+```powershell
+pip install repopact                # the CLI + reference validator, from PyPI
+repopact init --target ../your-repo # seed a valid RepoPact in a new repo
+cd ../your-repo
+repopact new work-item "Title of the work"   # stamps records (incl. the preflight marker)
+repopact validate
+repopact dashboard
+```
+
+`repopact` dispatches `init`, `adopt`, `validate`, `new`, `dashboard`, `spec`,
+`check-frozen`, `import-plan`, and `doctor`. Records are validated against `schemas/*.json`
+(structure) and by the validator (cross-record semantics; decision
+[`0003`](decisions/0003-validate-records-against-json-schemas.md)). Begin with
+[`AGENTS.md`](AGENTS.md), then [`governance/charter.md`](governance/charter.md) and
+[`governance/workflow.md`](governance/workflow.md).
+
+## Adopt an *existing* repository
+
+For a project that already has CODEOWNERS, CI workflows, and nested `AGENTS.md` contracts,
+`adopt` maps those existing signals into RepoPact records without overwriting anything:
+
+```powershell
+repopact adopt --target ../existing-repo --dry-run   # preview the plan, write nothing
+repopact adopt --target ../existing-repo             # create records, then validate
+repopact doctor                                      # diagnose + repair drift; migrate on upgrade
+```
+
+CODEOWNERS becomes scopes and roles; each `.github/workflows/*` becomes a binding-gate policy
+(plus invariant `INV-2` and a frozen-surface entry); every nested `AGENTS.md` is registered as
+a contract; git history seeds a first **inferred** evidence run, and the adoption record is
+recorded as **provisional** — honestly typed, not a fabricated "completed" claim. Adoption is
+idempotent.
+
+## 2.0: mandatory preflight + provenance-typed records
+
+Decision [`0021`](decisions/0021-preflight-mandatory-and-provenance.md) (supersedes 0018):
+
+- **Mandatory preflight (default on).** No work begins until a work item exists and
+  propagates through the pact; `repopact new` stamps the marker. Existing repos grandfather
+  their pre-2.0 items automatically — `adopt`/`init` set a preflight epoch and `doctor`
+  migrates on upgrade. *This is a breaking change*: run `repopact doctor` after upgrading.
+- **Provenance typing** (`concrete` / `provisional` / `inferred`, default `concrete`). This
+  is the principled escape from the *adoption trilemma*: `adopt` emits provisional/inferred
+  records so the result is both **valid** and **faithful** (reconstruction is labelled, not
+  faked). Completion still requires `concrete` evidence; `doctor` ratchets when it arrives.
+
+## Status is a filesystem transition
+
+Work moves between `work/active`, `work/blocked`, `work/deferred`, and `work/completed`; its
+`work-item.json` status must match its directory. Moving a work item never deletes its
+reasoning, decisions, or evidence links.
+
+## Derive over declare
+
+Anything computable from source records is generated, not authored by hand (the dashboard,
+audit-freshness views, and the derived blocks of `SPEC.md`). Only genuine sources are
+hand-maintained. See policy `001`.
+
+## Evaluation, formal model & the Proving Ground
+
+RepoPact is developed against its own evidence, not assertion. The `research/` lab notebook
+holds a [formal model](research/formal-model.md) (the L0–L5 kernel, the typed invariant
+lattice, the adoption trilemma), the pre-registered [experiment protocol](research/protocol.md)
+and [benchmark protocol](research/benchmark-protocol.md) (hypotheses H1–H13, falsification
+criteria, [threats to validity](research/threats-to-validity.md)), a [findings
+register](research/findings.md), and a full [paper draft](research/paper.md).
+
+**PactBench** — the runnable benchmark suite (pre-registered tasks measuring whether RepoPact
+enforcement reduces silent guarantee drift, with a model-agnostic harness and an S5 drift
+harness) — lives in the **[RepoPact Proving
+Ground](https://github.com/ForgeWireLabs/repopact-proving-ground)**, a throwaway-but-real
+project that consumes RepoPact from PyPI and is driven across every primitive, including cases
+designed to break it. RepoPact defines the *protocol* (`research/`); the Proving Ground hosts
+the runnable suite. *RepoPact defines the pact; the Proving Ground tests whether the pact
+holds under agent pressure.*
+
+## Ecosystem
+
+RepoPact is the work-governance layer of [ForgeWire Labs](https://github.com/ForgeWireLabs) —
+inspectable agentic infrastructure (*inspect the work, bound the authority, preserve the
+evidence*). It composes with Fabric (execution governance) and ForgeLink (human-agent
+communication governance), but is independently useful on its own.
+
+## License & version
+
+Apache-2.0 ([`LICENSE`](LICENSE), decision [`0002`](decisions/0002-license-apache-2.0.md)).
+The spec version is in [`VERSION`](VERSION); templates for every record type live in
+[`templates/`](templates/).

repopact-2.0.1/VERSION

@@ -0,0 +1 @@
+2.0.1

{repopact-2.0.0 → repopact-2.0.1}/scripts/doctor.py

@@ -170,6 +170,25 @@ def diagnose(root: Path) -> list[Finding]:
     return findings
 
 
+def _migrate_preflight(root: Path, today: date) -> list[str]:
+    """On upgrade to 2.0, grandfather pre-2.0 work items (decision 0021). If owners.json
+    declares no preflight config at all, set an epoch (required_from_date = today) so
+    existing items are exempt and only work created after the upgrade needs a marker. A repo
+    that already declares preflight (on or off) is left untouched."""
+    owners = root / "governance" / "owners.json"
+    if not owners.is_file():
+        return []
+    try:
+        data = json.loads(owners.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return []
+    if "preflight" in data:
+        return []
+    data["preflight"] = {"enabled": True, "required_from_date": today.isoformat()}
+    owners.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    return [f"set preflight epoch (required_from_date={today.isoformat()}) to grandfather pre-2.0 work items"]
+
+
 def _ratchet_provisional(root: Path) -> list[str]:
     """Ratchet provisional work items to concrete once every satisfied criterion rests on
     concrete evidence (decision 0021). Conservative and monotone: only upgrades."""
@@ -277,6 +296,9 @@ def fix(root: Path, today: date | None = None) -> list[str]:
     # 6. ratchet provisional records whose evidence is now concrete (decision 0021)
     actions.extend(_ratchet_provisional(root))
 
+    # 7. migrate preflight on upgrade: grandfather pre-2.0 work items (decision 0021)
+    actions.extend(_migrate_preflight(root, today))
+
     return actions
 
 

repopact-2.0.1/scripts/repopact.egg-info/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: repopact
+Version: 2.0.1
+Summary: A repository-native standard for durable agent work: binding invariants, evidence-gated work items, and drift audits.
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/ForgeWireLabs/repopact
+Project-URL: Repository, https://github.com/ForgeWireLabs/repopact
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jsonschema>=4.20
+Dynamic: license-file
+
+# RepoPact
+
+RepoPact is a **repository-native governance kernel for durable agent work**. It keeps the
+load-bearing state of a project — intent, authority, evidence, decisions, and drift — as
+typed, version-controlled records in the filesystem, so a new contributor or agent can
+recover where things stand *without* a prior conversation, and so the guarantees that matter
+cannot be silently weakened.
+
+> The repository is the pact: authority, intent, evidence, and history that survive every
+> session.
+
+`pip install repopact` · Apache-2.0 · current release **2.0.1**
+([changelog](decisions/0021-preflight-mandatory-and-provenance.md)).
+
+## How it relates to `AGENTS.md`
+
+`AGENTS.md` (and `CLAUDE.md`, editor rules) tell an agent *what to do* — they're
+instructions, plain Markdown, with no enforcement. RepoPact is the layer **above** them:
+
+> `AGENTS.md` tells the agent what to do. RepoPact proves it didn't quietly undo it.
+
+RepoPact's distinguishing primitive is the **binding invariant** — a declared guarantee with
+a rationale, an escalation path, and (where its logical type permits) a machine enforcer.
+That, plus evidence-gated completion and a filesystem state machine, is what turns a folder
+convention into a contract. `repopact adopt` ingests an existing `AGENTS.md` rather than
+replacing it (decision [`0020`](decisions/0020-launch-positioning-layer-above-agents-md.md)).
+
+## Core loop
+
+```text
+intent -> scoped authority -> work item -> implementation -> evidence -> audit -> history
+```
+
+![RepoPact core loop over a filesystem state machine](docs/assets/repopact-flow.svg)
+
+## Primitives
+
+1. **Charter & invariants** — principles (judgment) and binding invariants
+   (escalation-gated) in `governance/`.
+2. **Frozen surface** — paths and symbols that require operator approval (`--ack`) to change.
+3. **Scopes & roles** — layered `AGENTS.md` contracts plus a role/scope map in
+   `governance/owners.json`.
+4. **Work items** — narrative `README.md` + machine-readable `work-item.json` with
+   evidence-linked acceptance criteria. **Mandatory preflight** (2.0): a work item must be
+   recorded *before* implementation begins (`repopact new` stamps the marker).
+5. **Evidence** — immutable run manifests under `evidence/runs/`.
+6. **Decisions & policies** — durable choices (`decisions/`) and operating rules
+   (`governance/policies/`) whose rationale outlives any single work item.
+7. **Provenance** (2.0) — every record is `concrete`, `provisional`, or `inferred`.
+   `adopt` emits provisional/inferred records (honest, not fabricated); `doctor` ratchets
+   them to `concrete` as real evidence arrives. See *2.0 changes* below.
+8. **Reconciliation** — audits and a *generated* dashboard surface drift and review
+   staleness rather than hand-maintaining it.
+
+## Install & quick start
+
+```powershell
+pip install repopact                # the CLI + reference validator, from PyPI
+repopact init --target ../your-repo # seed a valid RepoPact in a new repo
+cd ../your-repo
+repopact new work-item "Title of the work"   # stamps records (incl. the preflight marker)
+repopact validate
+repopact dashboard
+```
+
+`repopact` dispatches `init`, `adopt`, `validate`, `new`, `dashboard`, `spec`,
+`check-frozen`, `import-plan`, and `doctor`. Records are validated against `schemas/*.json`
+(structure) and by the validator (cross-record semantics; decision
+[`0003`](decisions/0003-validate-records-against-json-schemas.md)). Begin with
+[`AGENTS.md`](AGENTS.md), then [`governance/charter.md`](governance/charter.md) and
+[`governance/workflow.md`](governance/workflow.md).
+
+## Adopt an *existing* repository
+
+For a project that already has CODEOWNERS, CI workflows, and nested `AGENTS.md` contracts,
+`adopt` maps those existing signals into RepoPact records without overwriting anything:
+
+```powershell
+repopact adopt --target ../existing-repo --dry-run   # preview the plan, write nothing
+repopact adopt --target ../existing-repo             # create records, then validate
+repopact doctor                                      # diagnose + repair drift; migrate on upgrade
+```
+
+CODEOWNERS becomes scopes and roles; each `.github/workflows/*` becomes a binding-gate policy
+(plus invariant `INV-2` and a frozen-surface entry); every nested `AGENTS.md` is registered as
+a contract; git history seeds a first **inferred** evidence run, and the adoption record is
+recorded as **provisional** — honestly typed, not a fabricated "completed" claim. Adoption is
+idempotent.
+
+## 2.0: mandatory preflight + provenance-typed records
+
+Decision [`0021`](decisions/0021-preflight-mandatory-and-provenance.md) (supersedes 0018):
+
+- **Mandatory preflight (default on).** No work begins until a work item exists and
+  propagates through the pact; `repopact new` stamps the marker. Existing repos grandfather
+  their pre-2.0 items automatically — `adopt`/`init` set a preflight epoch and `doctor`
+  migrates on upgrade. *This is a breaking change*: run `repopact doctor` after upgrading.
+- **Provenance typing** (`concrete` / `provisional` / `inferred`, default `concrete`). This
+  is the principled escape from the *adoption trilemma*: `adopt` emits provisional/inferred
+  records so the result is both **valid** and **faithful** (reconstruction is labelled, not
+  faked). Completion still requires `concrete` evidence; `doctor` ratchets when it arrives.
+
+## Status is a filesystem transition
+
+Work moves between `work/active`, `work/blocked`, `work/deferred`, and `work/completed`; its
+`work-item.json` status must match its directory. Moving a work item never deletes its
+reasoning, decisions, or evidence links.
+
+## Derive over declare
+
+Anything computable from source records is generated, not authored by hand (the dashboard,
+audit-freshness views, and the derived blocks of `SPEC.md`). Only genuine sources are
+hand-maintained. See policy `001`.
+
+## Evaluation, formal model & the Proving Ground
+
+RepoPact is developed against its own evidence, not assertion. The `research/` lab notebook
+holds a [formal model](research/formal-model.md) (the L0–L5 kernel, the typed invariant
+lattice, the adoption trilemma), the pre-registered [experiment protocol](research/protocol.md)
+and [benchmark protocol](research/benchmark-protocol.md) (hypotheses H1–H13, falsification
+criteria, [threats to validity](research/threats-to-validity.md)), a [findings
+register](research/findings.md), and a full [paper draft](research/paper.md).
+
+**PactBench** — the runnable benchmark suite (pre-registered tasks measuring whether RepoPact
+enforcement reduces silent guarantee drift, with a model-agnostic harness and an S5 drift
+harness) — lives in the **[RepoPact Proving
+Ground](https://github.com/ForgeWireLabs/repopact-proving-ground)**, a throwaway-but-real
+project that consumes RepoPact from PyPI and is driven across every primitive, including cases
+designed to break it. RepoPact defines the *protocol* (`research/`); the Proving Ground hosts
+the runnable suite. *RepoPact defines the pact; the Proving Ground tests whether the pact
+holds under agent pressure.*
+
+## Ecosystem
+
+RepoPact is the work-governance layer of [ForgeWire Labs](https://github.com/ForgeWireLabs) —
+inspectable agentic infrastructure (*inspect the work, bound the authority, preserve the
+evidence*). It composes with Fabric (execution governance) and ForgeLink (human-agent
+communication governance), but is independently useful on its own.
+
+## License & version
+
+Apache-2.0 ([`LICENSE`](LICENSE), decision [`0002`](decisions/0002-license-apache-2.0.md)).
+The spec version is in [`VERSION`](VERSION); templates for every record type live in
+[`templates/`](templates/).

{repopact-2.0.0 → repopact-2.0.1}/tests/test_validate_repo.py

@@ -318,6 +318,26 @@ class RepositoryValidationTests(unittest.TestCase):
         self.assertEqual("concrete", wi["provenance"])
         self.assertEqual([], [p.message for p in validate(repo)])
 
+    def test_doctor_migrates_preflight_on_upgrade(self) -> None:
+        # Simulate a pre-2.0 repo: governed, no preflight config, a marker-less legacy item.
+        # Under 2.0 default-on it fails; doctor grandfathers it (decision 0021).
+        repo = Path(self.temp.name) / "upgraded"
+        init_repo.bootstrap(repo)
+        self.write_json(repo / "governance" / "owners.json", lambda d: d.pop("preflight", None))
+        d = repo / "work" / "active" / "001-legacy"
+        d.mkdir(parents=True)
+        (d / "README.md").write_text("# legacy\n", encoding="utf-8")
+        (d / "work-item.json").write_text(json.dumps({
+            "id": "001", "title": "legacy", "status": "active",
+            "owner_scope": "governance", "affected_scopes": [], "depends_on": [],
+            "acceptance_criteria": [{"id": "AC-1", "text": "x", "state": "pending", "evidence": []}],
+            "created": "2020-01-01", "updated": "2020-01-01",
+        }), encoding="utf-8")
+        self.assertTrue(any("preflight" in p.message for p in validate(repo)))
+        actions = doctor.fix(repo)
+        self.assertTrue(any("preflight epoch" in a for a in actions))
+        self.assertEqual([], [p.message for p in validate(repo)])
+
     # --- L3 open obligations (formal-model §5: O-4 temporal, O-6 relational) ----------
     # Marked honestly: these invariant classes are not mechanizable on a single tree today;
     # they are enforced by human review (INV-4/INV-5) until O-4/O-6 are discharged.

repopact-2.0.0/PKG-INFO

@@ -1,125 +0,0 @@
-Metadata-Version: 2.4
-Name: repopact
-Version: 2.0.0
-Summary: A repository-native standard for durable agent work: binding invariants, evidence-gated work items, and drift audits.
-License: Apache-2.0
-Project-URL: Homepage, https://github.com/ForgeWireLabs/repopact
-Project-URL: Repository, https://github.com/ForgeWireLabs/repopact
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: jsonschema>=4.20
-Dynamic: license-file
-
-# RepoPact
-
-RepoPact is a repository-native operating system for durable agent work.
-It makes authority, intent, evidence, and architectural drift visible in the
-filesystem so that a new contributor or agent can recover the state of the
-project without depending on a prior conversation.
-
-> The repository is the pact: authority, intent, evidence, and history that
-> survive every session.
-
-## Why "pact"
-
-Conventions like `AGENTS.md`, ADRs, and issue trackers each capture a fragment of
-project knowledge, but none of them makes the *binding* part explicit — the
-guarantees an agent must not silently weaken. RepoPact's distinguishing primitive is
-the **binding invariant**: a declared guarantee with a rationale, an escalation path,
-and (where possible) a machine enforcer. That, plus evidence-gated completion and a
-filesystem state machine, is what turns a folder convention into a contract.
-
-## Core loop
-
-```text
-intent -> scoped authority -> work item -> implementation -> evidence -> audit -> history
-```
-
-![RepoPact core loop over a filesystem state machine](docs/assets/repopact-flow.svg)
-
-## Primitives
-
-1. **Charter & invariants**: principles (judgment) and binding invariants
-   (escalation-gated) in `governance/`.
-2. **Frozen surface**: paths and symbols that require operator approval to change.
-3. **Scopes & roles**: layered `AGENTS.md` files plus a role/scope map in
-   `governance/owners.json`.
-4. **Work items**: narrative `README.md` plus machine-readable `work-item.json`,
-   with evidence-linked acceptance criteria.
-5. **Evidence**: immutable run manifests under `evidence/runs/`.
-6. **Decisions & policies**: durable choices (`decisions/`) and operating rules
-   (`governance/policies/`) whose rationale outlives any single work item.
-7. **Reconciliation**: audits and a *generated* dashboard that surface drift and
-   review staleness rather than hand-maintaining it.
-
-## Quick start
-
-```powershell
-pip install -r requirements.txt
-python scripts/validate_repo.py
-python scripts/generate_dashboard.py
-python -m unittest discover -s tests -v
-python scripts/check_frozen_surface.py --base origin/main
-```
-
-![RepoPact validating itself and generating its dashboard](docs/assets/repopact-governance.svg)
-
-Records are validated against `schemas/*.json` (structure) and by the validator
-(cross-record semantics). See decision
-[`0003`](decisions/0003-validate-records-against-json-schemas.md).
-
-Begin with [`AGENTS.md`](AGENTS.md), then read
-[`governance/charter.md`](governance/charter.md) and
-[`governance/workflow.md`](governance/workflow.md).
-
-## Adopt into a new repository
-
-Install the CLI, then bootstrap:
-
-```powershell
-pipx install git+https://github.com/ForgeWireLabs/repopact   # or: pip install .
-repopact init --target ../your-repo                          # seed a valid RepoPact
-cd ../your-repo
-repopact new work-item "Title of the work"                   # stamp records from templates/
-repopact validate
-```
-
-`repopact` dispatches `init`, `adopt`, `validate`, `new`, `dashboard`, `spec`, and
-`check-frozen` against the current repository. The loose-script form still works
-(`python scripts/init_repo.py --target ...`) for repos that vendor the scripts.
-
-### Adopt an *existing* repository
-
-For a project that already has CODEOWNERS, CI workflows, and nested `AGENTS.md`
-contracts, `adopt` maps those existing signals into RepoPact records without
-overwriting anything:
-
-```powershell
-repopact adopt --target ../existing-repo --dry-run   # preview the plan, write nothing
-repopact adopt --target ../existing-repo             # create records, then validate
-```
-
-CODEOWNERS becomes scopes and roles; each `.github/workflows/*` becomes a binding-gate
-policy (plus invariant `INV-2` and a frozen-surface entry); every nested `AGENTS.md`
-is registered as a contract; git history seeds the first evidence run. It is
-idempotent — re-running skips records that already exist.
-
-`init_repo.py` writes the minimal valid source records, copies the schemas and
-tooling, and validates the result. Templates for every record type live in
-[`templates/`](templates/). RepoPact is licensed under Apache-2.0 (see
-[`LICENSE`](LICENSE) and decision [`0002`](decisions/0002-license-apache-2.0.md));
-its spec version is in [`VERSION`](VERSION).
-
-## Status is a filesystem transition
-
-Work moves between `work/active`, `work/blocked`, `work/deferred`, and
-`work/completed`. Its `work-item.json` status must match its directory. Moving a
-work item never deletes its reasoning, decisions, or evidence links.
-
-## Derive over declare
-
-Anything computable from source records is generated, not authored by hand. The
-dashboard and audit-freshness views are derived; the only hand-maintained files
-are genuine sources (charter, invariants, frozen surface, schemas, owners, work
-items, evidence, decisions, policies). See policy `001`.

repopact-2.0.0/README.md

@@ -1,112 +0,0 @@
-# RepoPact
-
-RepoPact is a repository-native operating system for durable agent work.
-It makes authority, intent, evidence, and architectural drift visible in the
-filesystem so that a new contributor or agent can recover the state of the
-project without depending on a prior conversation.
-
-> The repository is the pact: authority, intent, evidence, and history that
-> survive every session.
-
-## Why "pact"
-
-Conventions like `AGENTS.md`, ADRs, and issue trackers each capture a fragment of
-project knowledge, but none of them makes the *binding* part explicit — the
-guarantees an agent must not silently weaken. RepoPact's distinguishing primitive is
-the **binding invariant**: a declared guarantee with a rationale, an escalation path,
-and (where possible) a machine enforcer. That, plus evidence-gated completion and a
-filesystem state machine, is what turns a folder convention into a contract.
-
-## Core loop
-
-```text
-intent -> scoped authority -> work item -> implementation -> evidence -> audit -> history
-```
-
-![RepoPact core loop over a filesystem state machine](docs/assets/repopact-flow.svg)
-
-## Primitives
-
-1. **Charter & invariants**: principles (judgment) and binding invariants
-   (escalation-gated) in `governance/`.
-2. **Frozen surface**: paths and symbols that require operator approval to change.
-3. **Scopes & roles**: layered `AGENTS.md` files plus a role/scope map in
-   `governance/owners.json`.
-4. **Work items**: narrative `README.md` plus machine-readable `work-item.json`,
-   with evidence-linked acceptance criteria.
-5. **Evidence**: immutable run manifests under `evidence/runs/`.
-6. **Decisions & policies**: durable choices (`decisions/`) and operating rules
-   (`governance/policies/`) whose rationale outlives any single work item.
-7. **Reconciliation**: audits and a *generated* dashboard that surface drift and
-   review staleness rather than hand-maintaining it.
-
-## Quick start
-
-```powershell
-pip install -r requirements.txt
-python scripts/validate_repo.py
-python scripts/generate_dashboard.py
-python -m unittest discover -s tests -v
-python scripts/check_frozen_surface.py --base origin/main
-```
-
-![RepoPact validating itself and generating its dashboard](docs/assets/repopact-governance.svg)
-
-Records are validated against `schemas/*.json` (structure) and by the validator
-(cross-record semantics). See decision
-[`0003`](decisions/0003-validate-records-against-json-schemas.md).
-
-Begin with [`AGENTS.md`](AGENTS.md), then read
-[`governance/charter.md`](governance/charter.md) and
-[`governance/workflow.md`](governance/workflow.md).
-
-## Adopt into a new repository
-
-Install the CLI, then bootstrap:
-
-```powershell
-pipx install git+https://github.com/ForgeWireLabs/repopact   # or: pip install .
-repopact init --target ../your-repo                          # seed a valid RepoPact
-cd ../your-repo
-repopact new work-item "Title of the work"                   # stamp records from templates/
-repopact validate
-```
-
-`repopact` dispatches `init`, `adopt`, `validate`, `new`, `dashboard`, `spec`, and
-`check-frozen` against the current repository. The loose-script form still works
-(`python scripts/init_repo.py --target ...`) for repos that vendor the scripts.
-
-### Adopt an *existing* repository
-
-For a project that already has CODEOWNERS, CI workflows, and nested `AGENTS.md`
-contracts, `adopt` maps those existing signals into RepoPact records without
-overwriting anything:
-
-```powershell
-repopact adopt --target ../existing-repo --dry-run   # preview the plan, write nothing
-repopact adopt --target ../existing-repo             # create records, then validate
-```
-
-CODEOWNERS becomes scopes and roles; each `.github/workflows/*` becomes a binding-gate
-policy (plus invariant `INV-2` and a frozen-surface entry); every nested `AGENTS.md`
-is registered as a contract; git history seeds the first evidence run. It is
-idempotent — re-running skips records that already exist.
-
-`init_repo.py` writes the minimal valid source records, copies the schemas and
-tooling, and validates the result. Templates for every record type live in
-[`templates/`](templates/). RepoPact is licensed under Apache-2.0 (see
-[`LICENSE`](LICENSE) and decision [`0002`](decisions/0002-license-apache-2.0.md));
-its spec version is in [`VERSION`](VERSION).
-
-## Status is a filesystem transition
-
-Work moves between `work/active`, `work/blocked`, `work/deferred`, and
-`work/completed`. Its `work-item.json` status must match its directory. Moving a
-work item never deletes its reasoning, decisions, or evidence links.
-
-## Derive over declare
-
-Anything computable from source records is generated, not authored by hand. The
-dashboard and audit-freshness views are derived; the only hand-maintained files
-are genuine sources (charter, invariants, frozen surface, schemas, owners, work
-items, evidence, decisions, policies). See policy `001`.

repopact-2.0.0/VERSION

@@ -1 +0,0 @@
-2.0.0

repopact-2.0.0/scripts/repopact.egg-info/PKG-INFO

@@ -1,125 +0,0 @@
-Metadata-Version: 2.4
-Name: repopact
-Version: 2.0.0
-Summary: A repository-native standard for durable agent work: binding invariants, evidence-gated work items, and drift audits.
-License: Apache-2.0
-Project-URL: Homepage, https://github.com/ForgeWireLabs/repopact
-Project-URL: Repository, https://github.com/ForgeWireLabs/repopact
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: jsonschema>=4.20
-Dynamic: license-file
-
-# RepoPact
-
-RepoPact is a repository-native operating system for durable agent work.
-It makes authority, intent, evidence, and architectural drift visible in the
-filesystem so that a new contributor or agent can recover the state of the
-project without depending on a prior conversation.
-
-> The repository is the pact: authority, intent, evidence, and history that
-> survive every session.
-
-## Why "pact"
-
-Conventions like `AGENTS.md`, ADRs, and issue trackers each capture a fragment of
-project knowledge, but none of them makes the *binding* part explicit — the
-guarantees an agent must not silently weaken. RepoPact's distinguishing primitive is
-the **binding invariant**: a declared guarantee with a rationale, an escalation path,
-and (where possible) a machine enforcer. That, plus evidence-gated completion and a
-filesystem state machine, is what turns a folder convention into a contract.
-
-## Core loop
-
-```text
-intent -> scoped authority -> work item -> implementation -> evidence -> audit -> history
-```
-
-![RepoPact core loop over a filesystem state machine](docs/assets/repopact-flow.svg)
-
-## Primitives
-
-1. **Charter & invariants**: principles (judgment) and binding invariants
-   (escalation-gated) in `governance/`.
-2. **Frozen surface**: paths and symbols that require operator approval to change.
-3. **Scopes & roles**: layered `AGENTS.md` files plus a role/scope map in
-   `governance/owners.json`.
-4. **Work items**: narrative `README.md` plus machine-readable `work-item.json`,
-   with evidence-linked acceptance criteria.
-5. **Evidence**: immutable run manifests under `evidence/runs/`.
-6. **Decisions & policies**: durable choices (`decisions/`) and operating rules
-   (`governance/policies/`) whose rationale outlives any single work item.
-7. **Reconciliation**: audits and a *generated* dashboard that surface drift and
-   review staleness rather than hand-maintaining it.
-
-## Quick start
-
-```powershell
-pip install -r requirements.txt
-python scripts/validate_repo.py
-python scripts/generate_dashboard.py
-python -m unittest discover -s tests -v
-python scripts/check_frozen_surface.py --base origin/main
-```
-
-![RepoPact validating itself and generating its dashboard](docs/assets/repopact-governance.svg)
-
-Records are validated against `schemas/*.json` (structure) and by the validator
-(cross-record semantics). See decision
-[`0003`](decisions/0003-validate-records-against-json-schemas.md).
-
-Begin with [`AGENTS.md`](AGENTS.md), then read
-[`governance/charter.md`](governance/charter.md) and
-[`governance/workflow.md`](governance/workflow.md).
-
-## Adopt into a new repository
-
-Install the CLI, then bootstrap:
-
-```powershell
-pipx install git+https://github.com/ForgeWireLabs/repopact   # or: pip install .
-repopact init --target ../your-repo                          # seed a valid RepoPact
-cd ../your-repo
-repopact new work-item "Title of the work"                   # stamp records from templates/
-repopact validate
-```
-
-`repopact` dispatches `init`, `adopt`, `validate`, `new`, `dashboard`, `spec`, and
-`check-frozen` against the current repository. The loose-script form still works
-(`python scripts/init_repo.py --target ...`) for repos that vendor the scripts.
-
-### Adopt an *existing* repository
-
-For a project that already has CODEOWNERS, CI workflows, and nested `AGENTS.md`
-contracts, `adopt` maps those existing signals into RepoPact records without
-overwriting anything:
-
-```powershell
-repopact adopt --target ../existing-repo --dry-run   # preview the plan, write nothing
-repopact adopt --target ../existing-repo             # create records, then validate
-```
-
-CODEOWNERS becomes scopes and roles; each `.github/workflows/*` becomes a binding-gate
-policy (plus invariant `INV-2` and a frozen-surface entry); every nested `AGENTS.md`
-is registered as a contract; git history seeds the first evidence run. It is
-idempotent — re-running skips records that already exist.
-
-`init_repo.py` writes the minimal valid source records, copies the schemas and
-tooling, and validates the result. Templates for every record type live in
-[`templates/`](templates/). RepoPact is licensed under Apache-2.0 (see
-[`LICENSE`](LICENSE) and decision [`0002`](decisions/0002-license-apache-2.0.md));
-its spec version is in [`VERSION`](VERSION).
-
-## Status is a filesystem transition
-
-Work moves between `work/active`, `work/blocked`, `work/deferred`, and
-`work/completed`. Its `work-item.json` status must match its directory. Moving a
-work item never deletes its reasoning, decisions, or evidence links.
-
-## Derive over declare
-
-Anything computable from source records is generated, not authored by hand. The
-dashboard and audit-freshness views are derived; the only hand-maintained files
-are genuine sources (charter, invariants, frozen surface, schemas, owners, work
-items, evidence, decisions, policies). See policy `001`.