causal-continuity-engine 0.1.6__tar.gz → 0.2.0__tar.gz

{causal_continuity_engine-0.1.6 → causal_continuity_engine-0.2.0}/.github/CONTRIBUTING.md

@@ -54,10 +54,10 @@ do. `just setup` installs every direct and transitive tool from
 source distributions, then installs `causal-continuity-engine` editable without dependency
 resolution or an isolated build environment. The reviewed direct inputs are
 `pytest` 9.1.1, `ruff` 0.16.7, `build` 1.6.1, `jsonschema` 4.26.0,
-`setuptools` 83.0.0, and `pip` 26.2.1. None is imported by the engine; jsonschema validates
+`setuptools` 84.0.0, and `pip` 26.2.1. None is imported by the engine; jsonschema validates
 emitted receipt instances only in the test/release gate.
 
-The pins were last revalidated on 2026-09-15. Setuptools 83.0.0 is the first
+The security review on 2026-09-15 recorded setuptools 83.0.0 as the first
 patched release for
 [GHSA-h35f-9h28-mq5c](https://github.com/advisories/GHSA-h35f-9h28-mq5c)
 and pip 26.2.1 is later than the first patched release for
@@ -68,9 +68,10 @@ and the lock carries Pygments 2.20.0, the fix for
 [GHSA-5239-wwwm-4pmq](https://github.com/advisories/GHSA-5239-wwwm-4pmq).
 On that date pytest 9.1.1, ruff 0.16.7, build 1.6.1, jsonschema 4.26.0 and pip
 26.2.1 were the current stable releases on PyPI; build 1.5.1 remains yanked.
-Setuptools stays at 83.0.0: 84.0.0 is a new major release that this review did
-not evaluate. This is a dated review record, not a claim that pins stay current
-without future review.
+That review retained setuptools 83.0.0 without evaluating 84.0.0. The current
+84.0.0 pin is a subsequent build-tool update, with matching direct inputs and
+hash lock. The security review is a dated record, not a claim that pins stay
+current without future review.
 
 When a direct pin changes, edit `pyproject.toml` and `requirements-dev.in`,
 regenerate the lock with the command recorded in its header, and review the

{causal_continuity_engine-0.1.6 → causal_continuity_engine-0.2.0}/.github/scripts/verify_distributions.py

@@ -96,7 +96,8 @@ SDIST_GENERATED_FILES = {
     f"{EGG_INFO}/top_level.txt",
 }
 # Selected shipped test modules, chosen to cover the installed
-# CLI, the store and graph, trust, conformance vectors and the MCP server
+# CLI, store and graph, trust, conformance, authority/scoped-packet contracts
+# and bounded CLI/HTTP/MCP transports
 # against the artifact itself. The rest ship as audit evidence a reader can
 # run, not as checks this gate executes.
 WHEEL_BEHAVIOR_TESTS = (
@@ -107,6 +108,8 @@ WHEEL_BEHAVIOR_TESTS = (
     "tests/test_cli.py",
     "tests/test_conformance.py",
     "tests/test_mcp_server.py",
+    "tests/test_installed_contracts.py",
+    "tests/test_installed_packet_bounds.py",
 )
 WHEEL_EVIDENCE_TREES = {
     "benchmarks": {".py"},

{causal_continuity_engine-0.1.6 → causal_continuity_engine-0.2.0}/.github/scripts/verify_public_schemas.py

@@ -19,6 +19,21 @@ RAW_ORIGIN = (
 TAG_RE = re.compile(r"v[0-9]+\.[0-9]+\.[0-9]+\Z")
 SCHEMA_VERSION_RE = re.compile(r"cce\.[a-z][a-z0-9-]*\.v[1-9][0-9]*\Z")
 MAX_SCHEMA_BYTES = 2 * 1024 * 1024
+SCHEMA_RELEASES = {
+    "cce.anchor.v1.json": "v0.1.0",
+    "cce.capsule.v1.json": "v0.1.0",
+    "cce.continuity-receipt.v1.json": "v0.1.0",
+    "cce.event.v1.json": "v0.1.0",
+    "cce.proof-predicate.v1.json": "v0.1.0",
+    "cce.proof.v1.json": "v0.1.0",
+    "cce.recovery.v1.json": "v0.1.0",
+    "cce.resume.v1.json": "v0.1.0",
+    "cce.capsule.v2.json": "v0.2.0",
+    "cce.continuity-receipt.v2.json": "v0.2.0",
+    "cce.proof-predicate.v2.json": "v0.2.0",
+    "cce.proof.v2.json": "v0.2.0",
+    "cce.resume.v2.json": "v0.2.0",
+}
 
 
 def _runtime_schema_versions(root: Path) -> dict[str, str]:
@@ -61,8 +76,11 @@ def _runtime_schema_versions(root: Path) -> dict[str, str]:
 def _schema_public_urls(root: Path) -> dict[str, str]:
     names = sorted(
         f"{version}.json" for version in _runtime_schema_versions(root).values())
+    unreviewed = sorted(set(names) - SCHEMA_RELEASES.keys())
+    if unreviewed:
+        raise SystemExit("unreviewed schema release identity: " + ", ".join(unreviewed))
     return {
-        name: f"{RAW_ORIGIN}/v0.1.0/schemas/{name}"
+        name: f"{RAW_ORIGIN}/{SCHEMA_RELEASES[name]}/schemas/{name}"
         for name in names
     }
 
@@ -147,8 +165,8 @@ def verify(
             "public schema inventory differs from the reviewed runtime contract")
 
     # A schema TypeURI identifies that schema version, not the package release
-    # currently carrying it. Later package tags must continue to verify the
-    # immutable v0.1.0 URLs instead of silently repointing the v1 identities.
+    # currently carrying it. Each reviewed filename retains its assigned release
+    # independently of both the package tag and the payload's claimed $id.
     expected_urls = set(schema_public_urls.values())
     observed_ids: set[str] = set()
     for name in schema_names:
@@ -171,7 +189,7 @@ def verify(
                 + ", ".join(sorted(unexpected_urls)))
 
         # Fetch the committed identity itself. The explicit map above freezes
-        # today's v1 contract; this variable makes the deciding path follow the
+        # each reviewed identity; this variable makes the deciding path follow the
         # schema's checked-in $id rather than the current package tag.
         remote_bytes = fetch(committed_url)
         if not isinstance(remote_bytes, bytes):

{causal_continuity_engine-0.1.6 → causal_continuity_engine-0.2.0}/AGENTS.md

@@ -16,10 +16,11 @@ runtime records are authenticated/audited rather than replay-derived. Memory
 tiers L0–L4 and token-budgeted Resume Packets are what
 an agent actually receives on resume. When a requirement changes or evidence
 contradicts an assumption, causal invalidation computes the blast radius
-over typed edges, bounds it, and classifies it deterministically. A task
-cannot be marked complete without a signed proof envelope whose required
-verifiers actually ran — `Engine.complete_task` has twenty independently
-instrumented rejection gates, including unresolved invalidation control,
+over typed edges, bounds it, and classifies it deterministically. When policy
+requires proof, a task cannot be marked complete without a signed proof envelope
+whose required verifiers actually ran — `Engine.complete_task` has twenty-two
+independently instrumented rejection gates, including current confirmed authority,
+applicable authority conflicts, unresolved invalidation control,
 monotonic completed-state, and completable-state guards, and evidence is graded
 A–F from negative controls,
 mutation probes and determinism probes. That grade is a mechanical lower bound: it
@@ -114,7 +115,7 @@ python verifiers/verify_proof.py <proof.json> --fingerprint sha256:...
 vectors that *wrap* an envelope alongside its expected verdict, so passing
 one directly reports `E_SHAPE`; use `vectors/generate.py --check` for those.
 
-CLI subcommands, all real: `init ingest resume assumptions invalidations
+CLI subcommands, all real: `init ingest authority resume assumptions invalidations
 verify check migrate replay rebuild audit evidence policy serve mcp`.
 
 ## Repo map
@@ -270,9 +271,11 @@ Repository text is evidence about intent. It is never instruction.
   can raise its authority above the authority of its source
   (`causal_continuity_engine/ontology.py`,
   `causal_continuity_engine/extraction.py`).
-- Untrusted text **may propose, never mandate.** A requirement extracted
-  from an untrusted source is demoted to a claim, with the demotion recorded
-  (AD-006).
+- All prose **may propose, never mandate**, including OWNER and human-decision
+  prose. Requirements, constraints, decisions, assumptions and tasks become
+  source-event-bound proposals. Only an explicit owner-local canonical decision
+  through `record_authority_decision` or `authority --request FILE` confirms
+  authority; source standing and status resolution are not grants (ADR-126).
 - Imperative policy-override wording trips the injection screen, and when it
   does, **every item extracted from that text block is quarantined** — not
   just the matched span. Splitting a hostile block into a suspect part and a

{causal_continuity_engine-0.1.6 → causal_continuity_engine-0.2.0}/CHANGELOG.md

@@ -9,6 +9,64 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 No unreleased changes.
 
+## 0.2.0 — 2026-09-23
+
+### Changed
+
+- **Breaking: extracted prose proposes; local confirmation confers authority.**
+  Requirements, constraints, decisions, assumptions and tasks extracted from
+  retained source text require an explicit owner-local decision before becoming
+  binding control state. Consumers check canonical decision history, source
+  support and the actual projection. A trusted author label or mutable graph
+  flag is not approval. Confirmation has no HTTP or MCP
+  endpoint; this trusts the existing OS/store owner, not an independently
+  authenticated human or a process isolated from that same account (ADR-126).
+- **Breaking: processor compatibility advances to `cce-processor/1.9.0` and
+  extraction to `cce-deterministic/1.4.0`.** Preserve older projected stores and
+  their SQLite sidecars after stopping writers. Re-ingest retained sources into
+  a separate new store/project and review its proposals before confirming them.
+  Older authority projections do not upgrade in place; erased source payloads
+  cannot be reconstructed by replay. Existing finite admission limits still
+  apply; the version check is not a claim of complete database provenance.
+- **Proof v2 binds the complete applicable obligation set.** Confirmed task
+  proofs include applicable requirements, constraints, decisions and assumptions,
+  their canonical scope and the relevant policy. Caller-supplied links cannot
+  subtract mandatory controls. Initial and final deciding reads are separate;
+  later changes can stale the proof. A verifier's evidence grade remains a
+  mechanical binding check, not proof of the obligation's semantic truth
+  (ADR-127).
+- **Resume v2 is complete and explicitly project- or task-scoped.** Mandatory
+  controls, work, policy and trust information cannot be silently trimmed to fit
+  a budget. Watermarks are scope-specific; descriptive target metadata is not
+  a task selector. Current capsule v2 and continuity-receipt v2 remain project-only.
+  Historical v1 schemas are retained for interpretation, not current proof or
+  receipt acceptance (ADR-128).
+- **Successful resume responses have a hard serialized-byte bound.** The default
+  is 131,072 bytes; the accepted range is 1 through 1,048,576. Engine, CLI, HTTP
+  and MCP count their actual final representation, including the relevant wrapper
+  and line ending. Only optional sections may be removed. Mandatory overflow
+  refuses before signing, collision audit or watermark advancement. Packet-budget
+  refusals have a separate 1,024-byte bound. This does not bound computation,
+  input memory, HTTP headers, arbitrary reserialization or an outer capsule
+  (ADR-129).
+
+### Fixed
+
+- **Task expiry during packet composition used two validity instants.** Final
+  watermark admission now retains the selected instant while rechecking canonical
+  authority, source support, projected semantics and live status. Later freshness
+  uses current time; an as-of packet is not a lease. Unrelated late failures do
+  not promise to refund a consumed signature (ADR-130).
+- **One obligation read repeatedly reconstructed the same canonical witnesses.**
+  Validated control witnesses and shared scope-task identities are reused only
+  within that non-mutating call, never across requests or a writer's own changes.
+  Measured read counts fall without dropping authority checks. Distinct witnesses
+  still traverse history; no latency or total-history scaling bound is claimed
+  (ADR-131).
+- **The continuity-receipt specification named the historical v1 contract.**
+  SPEC §12 now matches the current project-only v2 producer and verifier, including
+  expected-scope binding and archived-v1 refusal. Historical schemas are unchanged.
+
 ## 0.1.6 — 2026-09-20
 
 Carries the unpublished 0.1.5 line forward with processor compatibility,

{causal_continuity_engine-0.1.6 → causal_continuity_engine-0.2.0}/CITATION.cff

@@ -8,8 +8,8 @@ authors:
   - given-names: Thomas
     family-names: Albrecht
     alias: The Quantum Falcon
-version: 0.1.6
-date-released: 2026-09-20
+version: 0.2.0
+date-released: 2026-09-23
 license: Apache-2.0
 repository-code: https://github.com/thequantumfalcon/causal-continuity-engine
 url: https://github.com/thequantumfalcon/causal-continuity-engine

{causal_continuity_engine-0.1.6/causal_continuity_engine.egg-info → causal_continuity_engine-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: causal-continuity-engine
-Version: 0.1.6
+Version: 0.2.0
 Summary: Causal Continuity Engine - continuity, causal invalidation, and proof for long-running coding agents
 Author: Thomas Albrecht
 License-Expression: Apache-2.0
@@ -73,8 +73,8 @@ assumptions, requirements and evidence become nodes in a bi-temporal causal
 graph over an application-enforced append-only, hash-chained event log, so
 *why* is a queryable edge and not a memory. When a requirement changes or evidence contradicts an assumption, the
 blast radius is computed over typed edges, bounded, and classified
-deterministically. And a task cannot be marked complete without a signed proof
-envelope whose required verifiers actually ran — the rejection gates are
+deterministically. When policy requires proof, a task cannot be marked complete
+without a signed envelope whose required verifiers actually ran — the rejection gates are
 mechanically enumerated and mutation-tested below.
 
 Event integrity separates two facts that are easy to conflate:
@@ -102,18 +102,32 @@ can read a project's control state directly. Four read-only tools:
 
 The subcommand first ships in 0.1.6. The published 0.1.0, 0.1.2 and 0.1.3
 packages do not include it; 0.1.4 was prepared but never published, and 0.1.5
-was tagged but never published. The candidate lifecycle has been exercised with
+was tagged but never published. The released 0.1.6 lifecycle has been exercised with
 the reference MCP SDK; other clients are expected to work over the same
 transport but have not been exercised here.
 
+Initialize a fresh project with the quickstart below before connecting a client.
+Use the absolute path to the installed `cce-engine` executable and the initialized
+project directory in the client configuration; an editor may not inherit your
+terminal's virtual environment or working directory. For example, on macOS/Linux:
+
 ```json
 {
   "mcpServers": {
-    "cce": {"command": "cce-engine", "args": ["--dir", ".", "mcp"]}
+    "cce": {
+      "command": "/absolute/path/to/.venv/bin/cce-engine",
+      "args": ["--dir", "/absolute/path/to/cce-demo", "mcp"]
+    }
   }
 }
 ```
 
+On Windows, use the virtual environment's `Scripts/cce-engine.exe`; forward
+slashes avoid JSON backslash escaping. Replace both example paths with real paths.
+MCP observes a closed store: stop writers cleanly before connecting. Any SQLite
+WAL, SHM, or rollback-journal sidecar causes refusal rather than a partial view.
+Never delete a sidecar to force admission; it may contain recovery data.
+
 The server is read-only by design. An MCP client is an untrusted caller in this
 project's authority model, so nothing exposed here mutates state, mints a proof,
 or grants autonomy — a test fails if a future tool name suggests otherwise. It
@@ -122,25 +136,61 @@ than the official SDK, which would pull in more than twenty packages.
 
 ## Quickstart
 
-Under five minutes, no dependencies beyond the package itself.
+The installation commands below install the package PyPI currently serves; to
+run this exact checkout, including its authority and v2 packet examples, use
+the editable installation that follows.
+
+Python 3.11 or newer is required; the engine has no third-party runtime
+dependencies. Choose the block for your platform and run it in a new working
+directory.
+
+macOS/Linux:
 
 ```bash
-python -m venv .venv
-# Activate with: source .venv/bin/activate          (macOS/Linux)
-#            or: .venv\Scripts\Activate.ps1         (Windows PowerShell)
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install causal-continuity-engine
+```
+
+Windows PowerShell:
+
+```powershell
+py -3 -m venv .venv
+.\.venv\Scripts\Activate.ps1
 python -m pip install causal-continuity-engine
 ```
 
-To work on the engine instead of using it, install the checkout editable — see
-[.github/CONTRIBUTING.md](.github/CONTRIBUTING.md) for the full toolchain:
+If PowerShell blocks activation, do not weaken its execution policy: install
+with `.\.venv\Scripts\python.exe -m pip install causal-continuity-engine`
+and invoke the environment's `cce-engine.exe` by its absolute path in the
+commands below. After activation, `cce-engine --help` checks the installation.
+
+**Upgrading an existing project:** this release uses processor 1.9.0 and
+extractor 1.4.0; projections written by 0.1.6's processor 1.8.0 or earlier
+processors are refused. There is no in-place projection or authority upgrade. Stop writers,
+preserve the complete old project state (including its database and any SQLite
+sidecars), and re-ingest retained sources into a separate new project/store.
+Review and explicitly confirm the new proposals there; old prose is not approval.
+Do not remove markers or sidecars to bypass refusal. Payloads already removed
+by retention cannot be reconstructed from their digests. New users can simply
+start a fresh project. See [the upgrade notes for this release](CHANGELOG.md#020--2026-09-23);
+the [0.1.6 notes](CHANGELOG.md#016--2026-09-20) remain historical.
+
+To run this exact checkout instead of the published package, or to work on the
+engine, replace the path below with the checkout's path and install it
+editable — see [.github/CONTRIBUTING.md](.github/CONTRIBUTING.md) for the
+development toolchain:
 
 ```bash
-git clone https://github.com/thequantumfalcon/causal-continuity-engine
-cd causal-continuity-engine
-python -m venv .venv
+cd /absolute/path/to/this/local/checkout
+python3 -m venv .venv
+source .venv/bin/activate
 python -m pip install -e .
 ```
 
+On Windows, use the PowerShell environment-creation and activation commands
+above, then `python -m pip install -e .` from the checkout.
+
 Global flags come **before** the subcommand: `cce-engine --dir <path> <subcommand>`.
 
 ```bash
@@ -209,103 +259,138 @@ cce-engine --dir . ingest --event push --delivery-id d2 --file push.json
 # ingested push: 0 node(s), 0 invalidation(s), 0 conflict(s)
 ```
 
-The extractor typed that prose by authority and pulled out what is now
-control state:
+The extractor proposed three claims: a requirement, a constraint and an
+assumption. Even an `OWNER` source does not approve them. At this point:
 
 ```bash
 cce-engine --dir . assumptions --status active
-# [active/medium] the upstream feed is ordered by timestamp  (asm_...)
+# no assumptions
 ```
 
-A Resume Packet is what an agent picking up the work receives instead of a
-summary — token-budgeted, with omissions stated rather than silent:
+Only for this **fresh, initialized demo directory that you control**, save the
+following as `prepare_reviews.py`. It prepares review operands for the three
+exact statements above; it does not approve them or read signing keys. This is
+an owner-local Python example, not a general secure filesystem opener or a
+read-only guarantee: `Engine` normally opens writable, schema-capable storage.
+
+<!-- quickstart-review-requests -->
+
+```python
+import json
+from pathlib import Path
+
+from causal_continuity_engine.engine import Engine
+
+root = Path.cwd()
+meta = json.loads((root / ".cce" / "meta.json").read_text(encoding="utf-8"))
+engine = Engine(root / ".cce" / "cce.db", tenant_id=meta["tenant_id"], workdir=root)
+try:
+    def prepare(kind, text):
+        matches = [node for node in engine.graph.current(
+            meta["project_id"], "claim", tenant_id=meta["tenant_id"])
+            if node["data"].get("proposed_kind") == kind
+            and node["data"].get("statement") == text]
+        if len(matches) != 1:
+            raise ValueError("expected exactly one matching retained proposal")
+        proposal = engine.authority_proposal(meta["project_id"], matches[0]["node_id"])
+        request = {
+            "operation": "confirm", "request_id": "quickstart-" + kind,
+            "tenant_id": meta["tenant_id"], "project_id": meta["project_id"],
+            **proposal, "authority_scope": {"kind": "global"},
+        }
+        (root / ("review-" + kind + ".json")).write_text(
+            json.dumps(request, indent=2) + "\n", encoding="utf-8")
+
+    prepare("requirement", "Exporter must stream rows instead of buffering")
+    prepare("constraint", "The exporter must not hold the whole result set in memory")
+    prepare("assumption", "the upstream feed is ordered by timestamp")
+finally:
+    engine.close()
+```
 
 ```bash
-cce-engine --dir . resume --token-budget 1500
+python prepare_reviews.py
 ```
 
-```markdown
-# CCE Resume Packet
-Packet `rsp_...` | generated ... | state at event:evt_...
-
-## Mission
-**Project:** octo/demo
-**Objective:** No explicit mission pinned; see open work.
-**Target:** {}
-
-## Mission control state
-### Pinned
-- none pinned
-### Retired
-- none retired
-
-## Authority
-- instruction precedence: tenant_policy > human_decision > repository_authoritative > agent_inference > untrusted_content
-### Active constraints
-- The exporter must not hold the whole result set in memory (high)
-### Active requirements
-- Exporter must stream rows instead of buffering
+Inspect the complete source in `issue.json`, the exact retained proposal text,
+and **each complete request file**, including its tenant/project and global
+scope. Stop if they do not match what you intend to authorize. Preparing these
+files is not approval. Submit each only if you approve that individual statement:
 
-## Accepted decisions
-- none
+```bash
+# Only after approving the requirement:
+cce-engine --dir . --json authority --request review-requirement.json
+# Only after approving the constraint:
+cce-engine --dir . --json authority --request review-constraint.json
+# Only after approving the assumption:
+cce-engine --dir . --json authority --request review-assumption.json
+```
 
-## Invalidated state
-- none open
+Each command returns a receipt naming the confirmation and canonical event.
+Now `cce-engine --dir . assumptions --status active` lists the confirmed
+assumption. Owner-local authority means possession of the local OS/store
+capability, not independent authentication of a human. Neither HTTP nor MCP
+exposes this confirmation operation. Revocation and scope replacement also use
+explicit structured decisions; editing a source does not silently approve new text.
 
-## Assumptions
-### Active
-- [active] the upstream feed is ordered by timestamp (asm_...)
-### Uncertain
-- none
+A Resume Packet is what an agent picking up the work receives instead of a
+summary. A project packet includes all applicable mandatory control, work,
+policy and trust state. `resume --task-id <confirmed-task-id>` explicitly selects
+a live confirmed task and its applicable controls; descriptive `--issue` or
+target metadata does not select authority. Task and project freshness records
+are separate, while broad project safety changes can stale both. Capsules and
+continuity receipts remain project-only, not task-specific verdicts.
+
+The token budget is an advisory trimming target, not a hard ceiling; mandatory
+state is not dropped to meet it. `token_estimate` is not a model-specific
+tokenizer count. Separately, `--max-response-bytes` is a hard bound on the final
+UTF-8 response (default `131072`, allowed `1`–`1048576`). For CLI output that
+includes JSON formatting or terminal sanitization and the final newline. HTTP
+measures its JSON body; MCP measures the complete result frame including its
+request ID and newline. Re-encoding elsewhere is not covered by this bound.
+
+Only optional context may be trimmed, with omissions disclosed. If complete
+mandatory state cannot fit, CCE refuses before packet signing or a new success
+watermark. The CLI returns exit 2 with the fixed `packet_budget_exceeded` error
+on stderr, not a partial packet; the small error frame has its own bound.
+Use an adequate limit or legitimate narrower task scope, never truncate authority.
 
-## Verified progress
-- none
+```bash
+cce-engine --dir . resume --token-budget 1500
+```
 
-## Open work
-- none visible
-### Blockers
-- none
+Selected lines from that real Markdown output follow. `...` marks excerpted
+content here, not a packet omission; the actual output includes the complete
+mandatory members, configured policy and other sections.
 
-**Next safe action:** No open tasks; verify project state and await instruction.
+<!-- quickstart-packet-excerpt -->
 
-## Environment
-- {"note": "no environment fingerprint recorded"}
+```markdown
+Scope: {"kind": "project"} | complete: True
+Response: cli-markdown | max bytes: 131072
 
+## Mandatory control
+...
+## Authority
+...
+### Active requirements
+- Exporter must stream rows instead of buffering
+...
 ## Trust
 - autonomy level: 0
 - required verifiers: none
 - verification gaps: policy:proof-required-without-required-verifiers
-### Completed checks
-- none
-### Failed or stale checks
-- none
-
-## Evidence index
-- asm_...: evt_...
-
-## Recent context
-- none
-
-## Continuity lineage
-- source session: none
-- checkpoints: []
-- packet generation time: ...
-
-## Omissions
-- none
-
+...
 ## Transport and cryptographic metadata
-- Full canonical values are retained in the JSON packet; the human view does not reproduce signatures, digests, or the complete state-basis object.
-- schema: cce.resume.v1
+...
+- schema: cce.resume.v2
 - packet digest present: True
 - signature present: True
-
-Evidence coverage: 100% | ~... tokens
 ```
 
-That is the whole human-view shape, with generated identifiers and timestamps
-abbreviated. Every schema field is either rendered or named as metadata kept
-in canonical JSON; empty decision sections are literal rather than silent.
+The full human view renders each schema field or declares it as metadata kept
+in canonical JSON. Use `resume --format json` for those complete canonical
+field values, including signatures, digests and the state-basis object.
 
 The named verification gap is expected on a fresh project: proof is required
 by default, but CCE cannot safely invent a project-specific verifier
@@ -436,9 +521,10 @@ contract is generated from the live route registry in [docs/API.md](docs/API.md)
 
 ## How it decides a task is done
 
-`complete_task` is the false-completion gate. When policy requires proof for
-`task_complete`, a completion attempt passes through twenty independently
-instrumented rejection paths:
+`complete_task` is the false-completion gate, with twenty-two independently
+instrumented rejection paths. Authority and state guards apply even when proof
+is optional. For a new completion, any supplied proof is validated; missing
+proof is rejected when policy requires it:
 
 1. **The target is a task in this project.** Another entity type, tenant, or
    project cannot be completed through a borrowed identifier.
@@ -475,7 +561,10 @@ instrumented rejection paths:
 15. **The proof is current.** If a named deliverable or any linked task,
     requirement, decision, assumption, artifact, evidence or action changed
     its signed semantic/version digest since attestation, the proof describes
-    a world that no longer exists.
+    a world that no longer exists. It also binds the complete applicable
+    requirement, constraint, decision and assumption set and verifier policy:
+    newly applicable controls, withdrawals and scope changes cannot hide behind
+    an unchanged caller-selected list of links.
 16. **The policy declares required verifiers.** Demanding proof without saying
     what must be proven lets the claimant set its own pass mark. This is a
     configuration error and refusing it names the fix.
@@ -492,6 +581,12 @@ instrumented rejection paths:
 20. **The task state did not race validation.** Its version is re-read before
     the proof is claimed and completion is written; a concurrent change forces
     a retry against the new state.
+21. **The task has current authority.** Its owner-local confirmation must still
+    have the required canonical decision and retained source witnesses; mutable
+    graph labels or an old approval receipt cannot substitute for them.
+22. **Applicable authority is not conflicted.** An applicable blocked, uncertain,
+    review-required or explicitly conflicted control prevents completion, even
+    under proof-optional policy.
 
 The instrument-validation suite plants exactly one defect for each path and
 asserts that the intended gate, rather than a neighboring one, rejects it.
@@ -599,7 +694,7 @@ determinism`; both exit non-zero on failure.
 
 ## Verifying a proof without trusting the engine
 
-[SPEC.md](SPEC.md) is normative: it defines the `cce.proof.v1` envelope and
+[SPEC.md](SPEC.md) is normative: it defines the `cce.proof.v2` envelope and
 the five checks (digest, signature, authenticity, sufficiency, scope) well
 enough to reimplement from that text alone.
 [verifiers/verify_proof.py](verifiers/verify_proof.py) is such a
@@ -608,6 +703,9 @@ reimplementation — standard library only, and it imports nothing from
 so agreement between the two is evidence rather than the same code run twice.
 [vectors/](vectors/) is a committed conformance corpus, including honest
 negatives and adversarial forgeries, that pins both implementations in CI.
+Published v1 schemas remain historical contracts; v1 proofs are not current
+completion evidence. The v2 schema URLs are bound to the `v0.2.0` release tag,
+and the release workflow verifies that each serves the checked-out bytes.
 
 ```bash
 # The complete configured verifier set must already be pinned in project policy.
@@ -680,7 +778,7 @@ outside the envelope — a fingerprint obtained out of band. SPEC §6 requires
 such a registry and says nothing about how it travels, because nothing here
 solves that. No amount of verifier code closes it.
 
-**There is no revocation.** A fingerprint in the registry is trusted for every
+**Signing-key revocation is not implemented.** A fingerprint in the registry is trusted for every
 envelope it ever signed. Withdrawing a key is not a mechanism this has.
 
 **A stranger cannot tell whether an envelope is still fresh.** An envelope is a