repopact 2.0.1__tar.gz → 2.1.0__tar.gz

{repopact-2.0.1 → repopact-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repopact
-Version: 2.0.1
+Version: 2.1.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
@@ -22,15 +22,15 @@ 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)).
+`pip install repopact` · Apache-2.0 · current release **2.1.0**
+([changelog](decisions/0024-release-2.1.0-proposed-lifecycle.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.
+> `AGENTS.md` tells an agent how to behave. RepoPact enforces and records whether the work respected the contract.
 
 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.
@@ -71,7 +71,8 @@ intent -> scoped authority -> work item -> implementation -> evidence -> audit -
 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 new work-item "Title of the work"   # stamps active work (incl. the preflight marker)
+repopact new work-item "Candidate idea" --status proposed
 repopact validate
 repopact dashboard
 ```
@@ -83,6 +84,14 @@ repopact dashboard
 [`AGENTS.md`](AGENTS.md), then [`governance/charter.md`](governance/charter.md) and
 [`governance/workflow.md`](governance/workflow.md).
 
+Alternative implementations can run the published conformance suite:
+
+```powershell
+python scripts/run_conformance.py --command "your-validator --root {repo}"
+```
+
+See [`CONFORMANCE.md`](CONFORMANCE.md) and [`conformance/`](conformance/).
+
 ## Adopt an *existing* repository
 
 For a project that already has CODEOWNERS, CI workflows, and nested `AGENTS.md` contracts,
@@ -115,9 +124,17 @@ Decision [`0021`](decisions/0021-preflight-mandatory-and-provenance.md) (superse
 
 ## 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.
+Work moves between lifecycle directories; its `work-item.json` status must match its
+directory. Moving a work item never deletes its reasoning, decisions, or evidence links.
+
+- `proposed`: captured candidate work that is not yet accepted or authorized for
+  implementation.
+- `active`: accepted work authorized for design or implementation.
+- `blocked`: accepted/current work that cannot proceed until a named condition changes.
+- `deferred`: accepted work intentionally postponed with rationale.
+- `completed`: delivered work whose acceptance criteria are evidence-closed.
+
+Active and completed work cannot depend on proposed work as if it were accepted.
 
 ## Derive over declare
 
@@ -132,7 +149,7 @@ holds a [formal model](research/formal-model.md) (the L0–L5 kernel, the typed
 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).
+register](research/findings.md), and the current [paper](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

{repopact-2.0.1 → repopact-2.1.0}/README.md

@@ -1,144 +1,161 @@
-# 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
+
+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.1.0**
+([changelog](decisions/0024-release-2.1.0-proposed-lifecycle.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 an agent how to behave. RepoPact enforces and records whether the work respected the contract.
+
+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 active work (incl. the preflight marker)
+repopact new work-item "Candidate idea" --status proposed
+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).
+
+Alternative implementations can run the published conformance suite:
+
+```powershell
+python scripts/run_conformance.py --command "your-validator --root {repo}"
+```
+
+See [`CONFORMANCE.md`](CONFORMANCE.md) and [`conformance/`](conformance/).
+
+## 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 lifecycle directories; its `work-item.json` status must match its
+directory. Moving a work item never deletes its reasoning, decisions, or evidence links.
+
+- `proposed`: captured candidate work that is not yet accepted or authorized for
+  implementation.
+- `active`: accepted work authorized for design or implementation.
+- `blocked`: accepted/current work that cannot proceed until a named condition changes.
+- `deferred`: accepted work intentionally postponed with rationale.
+- `completed`: delivered work whose acceptance criteria are evidence-closed.
+
+Active and completed work cannot depend on proposed work as if it were accepted.
+
+## 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 the current [paper](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.1.0/VERSION

@@ -0,0 +1 @@
+2.1.0

{repopact-2.0.1 → repopact-2.1.0}/pyproject.toml

@@ -31,10 +31,11 @@ py-modules = [
   "track_import",
   "takeover",
   "doctor",
-  "new",
-  "check_frozen_surface",
-  "frontmatter",
-]
+  "new",
+  "check_frozen_surface",
+  "frontmatter",
+  "run_conformance",
+]
 
 [tool.setuptools.package-dir]
 "" = "scripts"
@@ -45,5 +46,5 @@ version = { file = "VERSION" }
 # Seed content shipped so `repopact init` works from an installed wheel. These
 # reference the canonical top-level files (one source of truth — no duplication).
 [tool.setuptools.data-files]
-"share/repopact/schemas" = ["schemas/*.json"]
-"share/repopact/templates" = ["templates/*"]
+"share/repopact/schemas" = ["schemas/*.json"]
+"share/repopact/templates" = ["templates/*"]

repopact-2.1.0/schemas/conformance-manifest.schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "conformance-manifest.schema.json",
+  "type": "object",
+  "required": ["suite_version", "fixtures_root", "cases"],
+  "properties": {
+    "suite_version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"},
+    "spec_version_file": {"type": "string"},
+    "fixtures_root": {"type": "string", "minLength": 1},
+    "cases": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "path", "expect", "rules", "description"],
+        "properties": {
+          "id": {"type": "string", "minLength": 1},
+          "path": {"type": "string", "minLength": 1},
+          "overlay_on": {"type": "string", "minLength": 1},
+          "expect": {"enum": ["accept", "reject"]},
+          "expected_message": {"type": "string"},
+          "rules": {"type": "array", "items": {"type": "string"}, "minItems": 1},
+          "description": {"type": "string", "minLength": 1}
+        },
+        "allOf": [
+          {
+            "if": {"properties": {"expect": {"const": "reject"}}},
+            "then": {"required": ["expected_message", "overlay_on"]}
+          }
+        ]
+      }
+    }
+  }
+}

{repopact-2.0.1 → repopact-2.1.0}/schemas/work-item.schema.json

@@ -6,7 +6,7 @@
   "properties": {
     "id": {"type": "string", "pattern": "^[0-9]{3,}$"},
     "title": {"type": "string", "minLength": 1},
-    "status": {"enum": ["active", "blocked", "deferred", "completed"]},
+    "status": {"enum": ["proposed", "active", "blocked", "deferred", "completed"]},
     "owner_scope": {"type": "string", "minLength": 1},
     "affected_scopes": {"type": "array", "items": {"type": "string"}, "uniqueItems": true},
     "depends_on": {"type": "array", "items": {"type": "string", "pattern": "^[0-9]{3,}$"}, "uniqueItems": true},
@@ -39,4 +39,3 @@
     "updated": {"type": "string", "format": "date"}
   }
 }
-

{repopact-2.0.1 → repopact-2.1.0}/scripts/init_repo.py

@@ -11,13 +11,14 @@ from __future__ import annotations
 import argparse
 import json
 import shutil
+import site
 import sys
 from datetime import date, timedelta
 from pathlib import Path
 
 HERE = Path(__file__).resolve().parent          # directory holding the tooling modules
 CHECKOUT = HERE.parent                          # repo root when running from a checkout
-LIFECYCLE = ("active", "blocked", "deferred", "completed")
+LIFECYCLE = ("proposed", "active", "blocked", "deferred", "completed")
 MODULES = (
     "repo_model.py", "validate_repo.py", "generate_dashboard.py", "generate_spec.py",
     "init_repo.py", "new.py", "check_frozen_surface.py", "frontmatter.py", "repopact_cli.py",
@@ -26,13 +27,16 @@ MODULES = (
 
 def _seed_dir(name: str) -> Path:
     """Locate seed content (schemas/templates) in a checkout or an installed wheel."""
-    checkout = CHECKOUT / name
-    if checkout.is_dir():
-        return checkout
-    installed = Path(sys.prefix) / "share" / "repopact" / name
-    if installed.is_dir():
-        return installed
-    raise FileNotFoundError(f"cannot locate seed '{name}' (looked in {checkout} and {installed})")
+    candidates = [
+        CHECKOUT / name,
+        Path(sys.prefix) / "share" / "repopact" / name,
+        Path(site.USER_BASE) / "share" / "repopact" / name,
+    ]
+    for candidate in candidates:
+        if candidate.is_dir():
+            return candidate
+    looked = ", ".join(str(candidate) for candidate in candidates)
+    raise FileNotFoundError(f"cannot locate seed '{name}' (looked in {looked})")
 
 
 def _write(path: Path, text: str) -> None:

{repopact-2.0.1 → repopact-2.1.0}/scripts/new.py

@@ -16,6 +16,8 @@ import sys
 from datetime import date, datetime
 from pathlib import Path
 
+from repo_model import STATUSES
+
 ROOT = Path(__file__).resolve().parents[1]
 
 
@@ -32,11 +34,13 @@ def _next_numeric(paths: list[Path], width: int, start: int) -> str:
     return str(max(used + [start - 1]) + 1).zfill(width)
 
 
-def new_work_item(title: str, today: date, root: Path = ROOT) -> Path:
+def new_work_item(title: str, today: date, root: Path = ROOT, status: str = "active") -> Path:
+    if status not in STATUSES:
+        raise ValueError(f"unknown work-item status '{status}'")
     slug = slugify(title)
     existing = list((root / "work").glob("*/*/work-item.json"))
     item_id = _next_numeric([p.parent for p in existing], 3, 1)
-    directory = root / "work" / "active" / f"{item_id}-{slug}"
+    directory = root / "work" / status / f"{item_id}-{slug}"
     directory.mkdir(parents=True)
     # Mandatory preflight (decision 0021): creating the work item with `new` IS the
     # preflight act, so stamp the marker and concrete provenance up front. No work
@@ -44,7 +48,7 @@ def new_work_item(title: str, today: date, root: Path = ROOT) -> Path:
     created_at = datetime.combine(today, datetime.min.time()).isoformat() + "Z"
     manifest = {
         "$schema": "../../../schemas/work-item.schema.json",
-        "id": item_id, "title": title, "status": "active",
+        "id": item_id, "title": title, "status": status,
         "owner_scope": "governance", "affected_scopes": [], "depends_on": [],
         "provenance": "concrete",
         "preflight": {
@@ -83,10 +87,12 @@ def main() -> int:
     parser = argparse.ArgumentParser(description="Stamp a new record from a template")
     parser.add_argument("kind", choices=["work-item", "decision", "policy"])
     parser.add_argument("title")
+    parser.add_argument("--status", choices=STATUSES, default="active",
+                        help="Lifecycle status for a new work item")
     args = parser.parse_args()
     today = date.today()
     if args.kind == "work-item":
-        path = new_work_item(args.title, today)
+        path = new_work_item(args.title, today, status=args.status)
     else:
         path = new_markdown(args.kind, args.title, today)
     print(f"Created {path.relative_to(ROOT)}")

{repopact-2.0.1 → repopact-2.1.0}/scripts/plan_import.py

@@ -11,7 +11,7 @@ Supported sources (extensible):
 
 * **Plan directories** — `todos/`, `todo/`, `tasks/`, `plan/`, `planning/`, `backlog/`
   with one subdirectory or markdown file per item, optionally grouped under
-  `completed/`, `deferred/`, `blocked/`, `active/` lifecycle folders.
+  `proposed/`, `completed/`, `deferred/`, `blocked/`, `active/` lifecycle folders.
 * **Checklist files** — `TODO.md`, `TODOS.md`, `ROADMAP.md`, `BACKLOG.md`, `PLAN.md`,
   `TASKS.md` at the root: each `- [ ]` / `- [x]` line becomes a work item.
 
@@ -33,16 +33,23 @@ import adopt_repo  # reuse Report and _slug
 
 PLAN_DIR_NAMES = ("todos", "todo", "tasks", "plan", "planning", "backlog")
 CHECKLIST_FILES = ("TODO.md", "TODOS.md", "ROADMAP.md", "BACKLOG.md", "PLAN.md", "TASKS.md")
-LIFECYCLE_DIRS = {"completed", "deferred", "blocked", "active"}
+LIFECYCLE_DIRS = {"proposed", "completed", "deferred", "blocked", "active"}
 
 # source lifecycle -> (work status, acceptance-criterion state)
 _STATUS = {
+    "proposed": ("proposed", "pending"),
     "completed": ("completed", "waived"),
     "deferred": ("deferred", "pending"),
     "blocked": ("blocked", "pending"),
     "active": ("active", "pending"),
 }
-_EMOJI = {"completed": "✅ Complete", "deferred": "⏸️ Deferred", "blocked": "⛔ Blocked", "active": "📋 Active"}
+_EMOJI = {
+    "proposed": "Proposed",
+    "completed": "✅ Complete",
+    "deferred": "⏸️ Deferred",
+    "blocked": "⛔ Blocked",
+    "active": "📋 Active",
+}
 
 _SKIP_DIRS = {".git", ".venv", "node_modules", "__pycache__"}
 # Index/template/readme files in a plan directory are scaffolding, not plan items.
@@ -55,7 +62,7 @@ def _is_scaffold(name: str) -> bool:
 
 @dataclass
 class PlanItem:
-    lifecycle: str          # completed | deferred | blocked | active
+    lifecycle: str          # proposed | completed | deferred | blocked | active
     slug: str               # RepoPact slug (no leading number)
     title: str
     narrative: str          # markdown body to preserve

{repopact-2.0.1 → repopact-2.1.0}/scripts/repo_model.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import Any
 
 
-STATUSES = ("active", "blocked", "deferred", "completed")
+STATUSES = ("proposed", "active", "blocked", "deferred", "completed")
 
 # Directories that are not part of the governed tree: tooling caches and, notably,
 # test fixtures, which are self-contained sub-repositories validated on their own.
@@ -64,4 +64,3 @@ def discover_evidence_ids(root: Path) -> set[str]:
     for path in sorted((root / "evidence" / "runs").glob("*.json")):
         result.add(str(load_json(path).get("id", "")))
     return result
-

{repopact-2.0.1 → repopact-2.1.0}/scripts/repopact.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repopact
-Version: 2.0.1
+Version: 2.1.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
@@ -22,15 +22,15 @@ 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)).
+`pip install repopact` · Apache-2.0 · current release **2.1.0**
+([changelog](decisions/0024-release-2.1.0-proposed-lifecycle.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.
+> `AGENTS.md` tells an agent how to behave. RepoPact enforces and records whether the work respected the contract.
 
 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.
@@ -71,7 +71,8 @@ intent -> scoped authority -> work item -> implementation -> evidence -> audit -
 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 new work-item "Title of the work"   # stamps active work (incl. the preflight marker)
+repopact new work-item "Candidate idea" --status proposed
 repopact validate
 repopact dashboard
 ```
@@ -83,6 +84,14 @@ repopact dashboard
 [`AGENTS.md`](AGENTS.md), then [`governance/charter.md`](governance/charter.md) and
 [`governance/workflow.md`](governance/workflow.md).
 
+Alternative implementations can run the published conformance suite:
+
+```powershell
+python scripts/run_conformance.py --command "your-validator --root {repo}"
+```
+
+See [`CONFORMANCE.md`](CONFORMANCE.md) and [`conformance/`](conformance/).
+
 ## Adopt an *existing* repository
 
 For a project that already has CODEOWNERS, CI workflows, and nested `AGENTS.md` contracts,
@@ -115,9 +124,17 @@ Decision [`0021`](decisions/0021-preflight-mandatory-and-provenance.md) (superse
 
 ## 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.
+Work moves between lifecycle directories; its `work-item.json` status must match its
+directory. Moving a work item never deletes its reasoning, decisions, or evidence links.
+
+- `proposed`: captured candidate work that is not yet accepted or authorized for
+  implementation.
+- `active`: accepted work authorized for design or implementation.
+- `blocked`: accepted/current work that cannot proceed until a named condition changes.
+- `deferred`: accepted work intentionally postponed with rationale.
+- `completed`: delivered work whose acceptance criteria are evidence-closed.
+
+Active and completed work cannot depend on proposed work as if it were accepted.
 
 ## Derive over declare
 
@@ -132,7 +149,7 @@ holds a [formal model](research/formal-model.md) (the L0–L5 kernel, the typed
 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).
+register](research/findings.md), and the current [paper](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

{repopact-2.0.1 → repopact-2.1.0}/scripts/repopact.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 VERSION
 pyproject.toml
 schemas/audit-finding.schema.json
+schemas/conformance-manifest.schema.json
 schemas/evidence-run.schema.json
 schemas/frozen-surface.schema.json
 schemas/invariants.schema.json
@@ -19,6 +20,7 @@ scripts/new.py
 scripts/plan_import.py
 scripts/repo_model.py
 scripts/repopact_cli.py
+scripts/run_conformance.py
 scripts/takeover.py
 scripts/track_import.py
 scripts/validate_repo.py

{repopact-2.0.1 → repopact-2.1.0}/scripts/repopact.egg-info/top_level.txt

@@ -9,6 +9,7 @@ new
 plan_import
 repo_model
 repopact_cli
+run_conformance
 takeover
 track_import
 validate_repo

{repopact-2.0.1 → repopact-2.1.0}/scripts/repopact_cli.py

@@ -10,8 +10,10 @@ from __future__ import annotations
 
 import argparse
 import sys
-from datetime import date
-from pathlib import Path
+from datetime import date
+from pathlib import Path
+
+from repo_model import STATUSES
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -50,10 +52,12 @@ def main(argv: list[str] | None = None) -> int:
     p_spec = sub.add_parser("spec", help="Regenerate SPEC.md derived blocks")
     p_spec.add_argument("--root", type=Path, default=Path.cwd())
 
-    p_new = sub.add_parser("new", help="Stamp a new record from a template")
-    p_new.add_argument("kind", choices=["work-item", "decision", "policy"])
-    p_new.add_argument("title")
-    p_new.add_argument("--root", type=Path, default=Path.cwd())
+    p_new = sub.add_parser("new", help="Stamp a new record from a template")
+    p_new.add_argument("kind", choices=["work-item", "decision", "policy"])
+    p_new.add_argument("title")
+    p_new.add_argument("--root", type=Path, default=Path.cwd())
+    p_new.add_argument("--status", choices=STATUSES, default="active",
+                       help="Lifecycle status for a new work item")
 
     p_frz = sub.add_parser("check-frozen", help="Report frozen-surface changes in a diff range")
     p_frz.add_argument("--root", type=Path, default=Path.cwd())
@@ -169,10 +173,10 @@ def main(argv: list[str] | None = None) -> int:
         print("Generated SPEC.md derived blocks")
         return 0
 
-    if args.command == "new":
-        import new
-        if args.kind == "work-item":
-            path = new.new_work_item(args.title, date.today(), root)
+    if args.command == "new":
+        import new
+        if args.kind == "work-item":
+            path = new.new_work_item(args.title, date.today(), root, status=args.status)
         else:
             path = new.new_markdown(args.kind, args.title, date.today(), root)
         print(f"Created {path.relative_to(root)}")

repopact-2.1.0/scripts/run_conformance.py

@@ -0,0 +1,112 @@
+"""Run the published RepoPact conformance suite.
+
+The runner materializes each fixture as an isolated temporary repository, injects
+the canonical schemas from this checkout, runs a RepoPact implementation, and
+compares the result with conformance/manifest.json.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+MANIFEST = ROOT / "conformance" / "manifest.json"
+
+
+@dataclass(frozen=True)
+class CaseResult:
+    case_id: str
+    passed: bool
+    detail: str
+
+
+def load_manifest(path: Path = MANIFEST) -> dict:
+    with path.open(encoding="utf-8") as handle:
+        data = json.load(handle)
+    if not isinstance(data, dict):
+        raise ValueError(f"manifest must be a JSON object: {path}")
+    return data
+
+
+def _copy_overlay(src: Path, dst: Path) -> None:
+    for path in src.rglob("*"):
+        if path.is_dir() or path.name == "meta.json":
+            continue
+        target = dst / path.relative_to(src)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(path, target)
+
+
+def materialize_case(root: Path, fixtures_root: Path, case: dict) -> Path:
+    repo = root / "repo"
+    overlay_on = case.get("overlay_on")
+    if overlay_on:
+        shutil.copytree(fixtures_root / str(overlay_on), repo)
+        _copy_overlay(fixtures_root / str(case["path"]), repo)
+    else:
+        shutil.copytree(fixtures_root / str(case["path"]), repo)
+    shutil.copytree(ROOT / "schemas", repo / "schemas")
+    return repo
+
+
+def run_command(command: str, repo: Path) -> subprocess.CompletedProcess[str]:
+    rendered = command.format(repo=str(repo))
+    return subprocess.run(rendered, shell=True, text=True, capture_output=True)
+
+
+def evaluate_case(case: dict, command: str, fixtures_root: Path) -> CaseResult:
+    case_id = str(case["id"])
+    with tempfile.TemporaryDirectory(prefix=f"repopact-conformance-{case_id}-") as tmp:
+        repo = materialize_case(Path(tmp), fixtures_root, case)
+        proc = run_command(command, repo)
+    output = "\n".join(part for part in (proc.stdout, proc.stderr) if part)
+    expect = case.get("expect")
+    if expect == "accept":
+        passed = proc.returncode == 0
+        detail = "accepted" if passed else f"expected accept, exit={proc.returncode}: {output.strip()}"
+        return CaseResult(case_id, passed, detail)
+    expected = str(case.get("expected_message", ""))
+    passed = proc.returncode != 0 and expected in output
+    detail = (
+        f"rejected with '{expected}'"
+        if passed
+        else f"expected reject containing '{expected}', exit={proc.returncode}: {output.strip()}"
+    )
+    return CaseResult(case_id, passed, detail)
+
+
+def run_suite(command: str, manifest_path: Path = MANIFEST) -> list[CaseResult]:
+    manifest = load_manifest(manifest_path)
+    fixtures_root = manifest_path.parent / str(manifest.get("fixtures_root", "fixtures"))
+    return [evaluate_case(case, command, fixtures_root) for case in manifest.get("cases", [])]
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run the RepoPact conformance suite")
+    parser.add_argument("--manifest", type=Path, default=MANIFEST)
+    parser.add_argument(
+        "--command",
+        default=f'"{sys.executable}" "{ROOT / "scripts" / "validate_repo.py"}" --root "{{repo}}"',
+        help="Implementation command template; {repo} is replaced with the fixture repo path.",
+    )
+    args = parser.parse_args()
+
+    results = run_suite(args.command, args.manifest.resolve())
+    failed = [result for result in results if not result.passed]
+    for result in results:
+        status = "PASS" if result.passed else "FAIL"
+        print(f"{status} {result.case_id}: {result.detail}")
+    print(f"\n{len(results) - len(failed)}/{len(results)} conformance cases passed.")
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{repopact-2.0.1 → repopact-2.1.0}/scripts/takeover.py

@@ -197,7 +197,7 @@ def registry_scopes_inside(root: Path, d: Path) -> list[str]:
 # File types we scan for inbound references; everything else (binaries, build output) is skipped.
 _TEXT_EXTS = {".md", ".markdown", ".txt", ".rst", ".py", ".toml", ".yaml", ".yml",
               ".json", ".cfg", ".ini", ".sh", ".ps1"}
-_LIFECYCLE = {"completed", "deferred", "active", "blocked"}
+_LIFECYCLE = {"completed", "deferred", "active", "blocked", "proposed"}
 _MD_LINK = re.compile(r"(\]\()([^)\s]+)(\))")
 
 

{repopact-2.0.1 → repopact-2.1.0}/scripts/validate_repo.py

@@ -381,11 +381,18 @@ def validate_work(root: Path, owner_scopes: set[str], enforce_disjoint: bool, pr
         validate_work_preflight(item, manifest, preflight_cfg, problems)
         validate_provenance(item, ev_prov, manifest, problems)
 
-    all_ids = set(seen)
-    for item in items:
-        for dependency in item.data.get("depends_on", []):
-            if dependency not in all_ids:
-                problems.append(Problem(item.directory / "work-item.json", f"unknown dependency '{dependency}'"))
+    all_ids = set(seen)
+    status_by_id = {item.item_id: item.status for item in items}
+    for item in items:
+        for dependency in item.data.get("depends_on", []):
+            if dependency not in all_ids:
+                problems.append(Problem(item.directory / "work-item.json", f"unknown dependency '{dependency}'"))
+            elif item.status in ("active", "completed") and status_by_id.get(dependency) == "proposed":
+                problems.append(Problem(
+                    item.directory / "work-item.json",
+                    f"{item.status} work item depends on proposed work item '{dependency}'; "
+                    "proposed work is not accepted implementation authority",
+                ))
 
     detect_dependency_cycles(items, all_ids, problems)
     if enforce_disjoint:

{repopact-2.0.1 → repopact-2.1.0}/tests/test_conformance.py

@@ -1,9 +1,9 @@
-"""Conformance corpus test (work item 006, issue #4).
+"""Conformance corpus test (work items 006 and 019).
 
-Validates the fixtures under tests/fixtures/: the valid baseline must be accepted,
-and each invalid overlay must be rejected with its declared message. Fixtures do
-not vendor schemas; the canonical schemas/ are injected here so a fixture can never
-pass against a stale schema copy (no drift).
+Validates the published suite under conformance/: the valid baseline must be
+accepted, and each invalid overlay must be rejected with its declared message.
+Fixtures do not vendor schemas; the canonical schemas/ are injected here so a
+fixture can never pass against a stale schema copy (no drift).
 """
 
 from __future__ import annotations
@@ -15,12 +15,17 @@ import tempfile
 import unittest
 from pathlib import Path
 
+import jsonschema
+
 ROOT = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(ROOT / "scripts"))
 
 from validate_repo import validate  # noqa: E402
 
-FIXTURES = ROOT / "tests" / "fixtures"
+import run_conformance  # noqa: E402
+
+MANIFEST = ROOT / "conformance" / "manifest.json"
+FIXTURES = ROOT / "conformance" / "fixtures"
 VALID = FIXTURES / "valid"
 INVALID = FIXTURES / "invalid"
 
@@ -39,6 +44,22 @@ def build_repo(dst: Path, overlay: Path | None = None) -> Path:
 
 
 class ConformanceTests(unittest.TestCase):
+    def test_manifest_is_structurally_valid(self) -> None:
+        manifest = json.loads(MANIFEST.read_text(encoding="utf-8"))
+        schema = json.loads((ROOT / "schemas" / "conformance-manifest.schema.json").read_text(encoding="utf-8"))
+        jsonschema.Draft202012Validator(schema).validate(manifest)
+        self.assertEqual((ROOT / "VERSION").read_text(encoding="utf-8").strip(), manifest["suite_version"])
+        for case in manifest["cases"]:
+            self.assertTrue((FIXTURES / case["path"]).exists(), case["path"])
+
+    def test_manifest_matches_reference_suite(self) -> None:
+        results = run_conformance.run_suite(
+            f'"{sys.executable}" "{ROOT / "scripts" / "validate_repo.py"}" --root "{{repo}}"',
+            MANIFEST,
+        )
+        self.assertTrue(results, "no conformance cases found")
+        self.assertEqual([], [result.detail for result in results if not result.passed])
+
     def test_valid_fixture_is_accepted(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             repo = build_repo(Path(tmp) / "repo")

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

@@ -48,17 +48,23 @@ class RepositoryValidationTests(unittest.TestCase):
         mutate(data)
         path.write_text(json.dumps(data), encoding="utf-8")
 
-    def add_active_item(self, item_id: str, owner_scope: str = "work", preflight: bool = True) -> None:
-        directory = self.root / "work" / "active" / f"{item_id}-probe"
-        directory.mkdir(parents=True)
-        (directory / "README.md").write_text("# probe\n", encoding="utf-8")
-        data = {
-            "id": item_id,
-            "title": "probe",
-            "status": "active",
-            "owner_scope": owner_scope,
-            "affected_scopes": [],
-            "depends_on": [],
+    def add_work_item(
+        self,
+        item_id: str,
+        status: str = "active",
+        owner_scope: str = "work",
+        preflight: bool = True,
+    ) -> None:
+        directory = self.root / "work" / status / f"{item_id}-probe"
+        directory.mkdir(parents=True)
+        (directory / "README.md").write_text("# probe\n", encoding="utf-8")
+        data = {
+            "id": item_id,
+            "title": "probe",
+            "status": status,
+            "owner_scope": owner_scope,
+            "affected_scopes": [],
+            "depends_on": [],
             "provenance": "concrete",
             "acceptance_criteria": [{"id": "AC-1", "text": "x", "state": "pending", "evidence": []}],
             "created": "2026-06-15",
@@ -69,9 +75,12 @@ class RepositoryValidationTests(unittest.TestCase):
                 "created_before_work_started": True,
                 "created_at": "2026-06-15T00:00:00Z",
                 "note": "probe",
-            }
-        (directory / "work-item.json").write_text(json.dumps(data), encoding="utf-8")
-
+            }
+        (directory / "work-item.json").write_text(json.dumps(data), encoding="utf-8")
+
+    def add_active_item(self, item_id: str, owner_scope: str = "work", preflight: bool = True) -> None:
+        self.add_work_item(item_id, "active", owner_scope, preflight)
+
     # --- baseline -----------------------------------------------------------
 
     def test_repository_is_valid(self) -> None:
@@ -90,10 +99,27 @@ class RepositoryValidationTests(unittest.TestCase):
         self.write_json(path, lambda d: (d["acceptance_criteria"][0].update({"state": "satisfied", "evidence": []})))
         self.assertTrue(any("satisfied without evidence" in v for v in self.problems()))
 
-    def test_completed_item_cannot_have_pending_criteria(self) -> None:
-        path = self.manifest()
-        self.write_json(path, lambda d: (d["acceptance_criteria"][0].update({"state": "pending", "evidence": []})))
-        self.assertTrue(any("completed item has pending criterion" in v for v in self.problems()))
+    def test_completed_item_cannot_have_pending_criteria(self) -> None:
+        path = self.manifest()
+        self.write_json(path, lambda d: (d["acceptance_criteria"][0].update({"state": "pending", "evidence": []})))
+        self.assertTrue(any("completed item has pending criterion" in v for v in self.problems()))
+
+    def test_valid_proposed_work_item_validates(self) -> None:
+        self.add_work_item("900", status="proposed")
+        self.assertEqual([], self.problems())
+
+    def test_invalid_proposed_work_item_fails_structure_validation(self) -> None:
+        self.add_work_item("900", status="proposed")
+        path = self.root / "work" / "proposed" / "900-probe" / "work-item.json"
+        self.write_json(path, lambda d: d.pop("title"))
+        self.assertTrue(any("missing fields: title" in v for v in self.problems()))
+
+    def test_active_work_cannot_depend_on_proposed_work(self) -> None:
+        self.add_work_item("900", status="proposed")
+        self.add_active_item("901")
+        active = self.root / "work" / "active" / "901-probe" / "work-item.json"
+        self.write_json(active, lambda d: d.__setitem__("depends_on", ["900"]))
+        self.assertTrue(any("depends on proposed work item '900'" in v for v in self.problems()))
 
     def test_readme_checkbox_parity_flags_contradiction(self) -> None:
         path = self.manifest()
@@ -398,10 +424,11 @@ class RepositoryValidationTests(unittest.TestCase):
 
     # --- bootstrap (003 B1) -------------------------------------------------
 
-    def test_bootstrap_produces_valid_repo(self) -> None:
-        target = Path(self.temp.name) / "seeded"
-        init_repo.bootstrap(target)
-        self.assertEqual([], [p.message for p in validate(target)])
+    def test_bootstrap_produces_valid_repo(self) -> None:
+        target = Path(self.temp.name) / "seeded"
+        init_repo.bootstrap(target)
+        self.assertTrue((target / "work" / "proposed").is_dir())
+        self.assertEqual([], [p.message for p in validate(target)])
 
     # --- SPEC generator determinism (004) ----------------------------------
 
@@ -418,12 +445,21 @@ class RepositoryValidationTests(unittest.TestCase):
     def test_cli_validate_returns_zero_on_valid_repo(self) -> None:
         self.assertEqual(0, repopact_cli.main(["validate", "--root", str(self.root)]))
 
-    def test_cli_new_stamps_a_valid_record(self) -> None:
-        rc = repopact_cli.main(["new", "work-item", "Cli Probe", "--root", str(self.root)])
-        self.assertEqual(0, rc)
-        stamped = list((self.root / "work" / "active").glob("*-cli-probe/work-item.json"))
-        self.assertEqual(1, len(stamped))
-        self.assertEqual([], [p.message for p in validate(self.root)])
+    def test_cli_new_stamps_a_valid_record(self) -> None:
+        rc = repopact_cli.main(["new", "work-item", "Cli Probe", "--root", str(self.root)])
+        self.assertEqual(0, rc)
+        stamped = list((self.root / "work" / "active").glob("*-cli-probe/work-item.json"))
+        self.assertEqual(1, len(stamped))
+        self.assertEqual([], [p.message for p in validate(self.root)])
+
+    def test_cli_new_can_stamp_proposed_work_item(self) -> None:
+        rc = repopact_cli.main(["new", "work-item", "Cli Proposal", "--status", "proposed", "--root", str(self.root)])
+        self.assertEqual(0, rc)
+        stamped = list((self.root / "work" / "proposed").glob("*-cli-proposal/work-item.json"))
+        self.assertEqual(1, len(stamped))
+        data = json.loads(stamped[0].read_text(encoding="utf-8"))
+        self.assertEqual("proposed", data["status"])
+        self.assertEqual([], [p.message for p in validate(self.root)])
 
     # --- proving-ground hardening (007) -------------------------------------
 

repopact-2.0.1/VERSION

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