phase-loop-runtime 0.3.0__tar.gz → 0.5.0__tar.gz

{phase_loop_runtime-0.3.0 → phase_loop_runtime-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.3.0
+Version: 0.5.0
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author: ViperJuice
 License-Expression: Apache-2.0
@@ -18,7 +18,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: baml-py<0.223,>=0.222
 Requires-Dist: pydantic<3,>=2
 Requires-Dist: PyYAML<7,>=6
-Requires-Dist: consiliency-contract<0.7,>=0.6.3
+Requires-Dist: consiliency-contract<0.7,>=0.6.5
 Requires-Dist: jsonschema<5,>=4
 Requires-Dist: tomli<3,>=2; python_version < "3.11"
 
@@ -104,3 +104,50 @@ The closeout verdict is runner-authoritative: when the runner rejects a child's
 closeout, the persisted `terminal-summary.json` reflects the runner's blocking verdict
 (the child's self-reported `complete`/`passed` is not overlaid back), preventing a
 stale "complete" summary from reconcile-skipping the work on the next run.
+
+## Conformance library (one library, two roles)
+
+`phase_loop_runtime.conformance` is the named, stable, importable surface for the
+deterministic `.consiliency/` conformance evaluator. It is a re-export (not a
+re-implementation) of the same function the actor already runs, so an **external
+CR-fence** — in gp CI, a git-host pre-merge check, anywhere — can import and run
+the identical check:
+
+```python
+from phase_loop_runtime.conformance import scan_consiliency_gates
+
+verdict = scan_consiliency_gates("/path/to/repo")   # {"status": "passed" | "warn" | "blocked" | "skipped", "gates": {...}, ...}
+```
+
+The surface also exposes the pure cores (`evaluate_git_discipline`,
+`self_heal_partition`, `evaluate_governance_scope`) for consumers that already
+hold the injected facts.
+
+**Two roles, one library.** This is meant to be mounted BOTH as the actor-side
+self-check (a pre-PR sanity pass the author runs locally) AND as the
+authoritative CR-fence (the real validator). The actor-side result is **never
+authoritative** — the fence always re-runs the check itself. Because it is the
+same function versioned with the same vendored `consiliency_contract`, the honest
+actor sees exactly the verdict the fence will; a stale or dishonest actor result
+simply does not matter.
+
+**Scope.** This surface asserts the L0 **shape + governance** tier only. The
+cert-schema tier and authority/provenance verification are explicitly out of
+scope (delegated downstream / to gp).
+
+### `consiliency-ingest --check-only`
+
+`--check-only` decouples "run the check" from "is this repo adopted". It is
+strictly read-only (never shapes; ignores `--adopt`). It makes the exit code
+verdict-significant so a pre-PR actor is never misled into reading a no-op — or a
+failing verify — as a pass:
+
+| Repo state | mode | exit |
+|---|---|---|
+| adopted, verify clean (or `warn`) | `verify` | `0` |
+| adopted, gate scan `blocked` | `verify` | `1` |
+| un-adopted (no `.consiliency/manifest`) | `not-adopted` | `3` |
+| usage error | — | `2` |
+
+The plain (non-`--check-only`) path is unchanged — it keeps the silent green
+`skipped` no-op on an un-adopted repo and its existing exit `0`.

{phase_loop_runtime-0.3.0 → phase_loop_runtime-0.5.0}/README.md

@@ -80,3 +80,50 @@ The closeout verdict is runner-authoritative: when the runner rejects a child's
 closeout, the persisted `terminal-summary.json` reflects the runner's blocking verdict
 (the child's self-reported `complete`/`passed` is not overlaid back), preventing a
 stale "complete" summary from reconcile-skipping the work on the next run.
+
+## Conformance library (one library, two roles)
+
+`phase_loop_runtime.conformance` is the named, stable, importable surface for the
+deterministic `.consiliency/` conformance evaluator. It is a re-export (not a
+re-implementation) of the same function the actor already runs, so an **external
+CR-fence** — in gp CI, a git-host pre-merge check, anywhere — can import and run
+the identical check:
+
+```python
+from phase_loop_runtime.conformance import scan_consiliency_gates
+
+verdict = scan_consiliency_gates("/path/to/repo")   # {"status": "passed" | "warn" | "blocked" | "skipped", "gates": {...}, ...}
+```
+
+The surface also exposes the pure cores (`evaluate_git_discipline`,
+`self_heal_partition`, `evaluate_governance_scope`) for consumers that already
+hold the injected facts.
+
+**Two roles, one library.** This is meant to be mounted BOTH as the actor-side
+self-check (a pre-PR sanity pass the author runs locally) AND as the
+authoritative CR-fence (the real validator). The actor-side result is **never
+authoritative** — the fence always re-runs the check itself. Because it is the
+same function versioned with the same vendored `consiliency_contract`, the honest
+actor sees exactly the verdict the fence will; a stale or dishonest actor result
+simply does not matter.
+
+**Scope.** This surface asserts the L0 **shape + governance** tier only. The
+cert-schema tier and authority/provenance verification are explicitly out of
+scope (delegated downstream / to gp).
+
+### `consiliency-ingest --check-only`
+
+`--check-only` decouples "run the check" from "is this repo adopted". It is
+strictly read-only (never shapes; ignores `--adopt`). It makes the exit code
+verdict-significant so a pre-PR actor is never misled into reading a no-op — or a
+failing verify — as a pass:
+
+| Repo state | mode | exit |
+|---|---|---|
+| adopted, verify clean (or `warn`) | `verify` | `0` |
+| adopted, gate scan `blocked` | `verify` | `1` |
+| un-adopted (no `.consiliency/manifest`) | `not-adopted` | `3` |
+| usage error | — | `2` |
+
+The plain (non-`--check-only`) path is unchanged — it keeps the silent green
+`skipped` no-op on an un-adopted repo and its existing exit `0`.

{phase_loop_runtime-0.3.0 → phase_loop_runtime-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "phase-loop-runtime"  # PyPI dist name; NOT "agent-harness" (an unrelated third-party PyPI project)
-version = "0.3.0"
+version = "0.5.0"
 description = "Harness-neutral phase-loop orchestration runtime and CLI"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,7 +32,17 @@ dependencies = [
     # < 0.6.2 stays safe; the floor guarantees the teeth are present. Warn-default remains;
     # human_required is never set. (0.6.0 shipped self-inconsistent version refs -> fixed in
     # 0.6.1, contract PR #18.)
-    "consiliency-contract>=0.6.3,<0.7",
+    #
+    # PIN (PSCAT-PL, roadmap Phase 2B): floor at 0.6.5 -- ships the
+    # `protected_source_categories` registry that OWNS the coarse
+    # protected_source_category vocabulary (the six pre-existing buckets +
+    # `governance_contracts`). phase-loop reads that registry via
+    # `consiliency_contract.load_registry` and validates against it as the SoT
+    # (models.py `protected_source_categories()`), replacing the hardcoded enum.
+    # Registry-present is authoritative; the runtime still degrades to the legacy
+    # six-tuple if a caller runs an older contract (no hard crash), but this floor
+    # guarantees the contract-owned vocabulary (incl. governance_contracts) is live.
+    "consiliency-contract>=0.6.5,<0.7",
     "jsonschema>=4,<5",
     # Advisor Board config loader (ABDREG) parses advisor-boards.toml. tomllib is
     # stdlib on 3.11+; on the 3.10 requires-python floor it is absent, so pull in

{phase_loop_runtime-0.3.0 → phase_loop_runtime-0.5.0}/src/phase_loop_runtime/__init__.py

@@ -3,6 +3,7 @@
 __all__ = [
     "__version__",
     "cli",
+    "conformance",
     "discovery",
     "handoff",
     "maintenance",
@@ -17,4 +18,4 @@ __all__ = [
     "state_ops",
 ]
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"

{phase_loop_runtime-0.3.0 → phase_loop_runtime-0.5.0}/src/phase_loop_runtime/_contract_docs/phase-loop/runtime-boundary.md

@@ -129,6 +129,7 @@ roots. See `docs/phase-loop/spec-discovery-roots.md`.
 The following modules under `phase_loop_runtime.*` are considered public:
 
 - `phase_loop_runtime.cli`: CLI entrypoint and parser definition.
+- `phase_loop_runtime.conformance`: Named conformance-check surface (the six L0 consiliency gates) for actor-side self-check and the CR-fence.
 - `phase_loop_runtime.discovery`: Roadmap and repository resolution.
 - `phase_loop_runtime.handoff`: TUI handoff generation and metadata.
 - `phase_loop_runtime.models`: Core data models, schemas, and literals.

{phase_loop_runtime-0.3.0 → phase_loop_runtime-0.5.0}/src/phase_loop_runtime/advisor_board/CONTRACTS.md

@@ -264,11 +264,14 @@ building `artifact: str` forces the caller to hold the whole (20k+ token) bundle
 its own context. `artifact_ref` / `brief_ref` promote that to by-reference ingestion:
 the caller passes a PATH and the runtime reads it.
 
-- **Entry points.** `invoke_panel`, `invoke_board`, and `invoke_panel_request` accept
-  keyword-only `artifact_ref: str | Sequence[str] | None` and `brief_ref: str | None`
+- **Entry points.** `invoke_panel` and `invoke_board` accept keyword-only
+  `artifact_ref: str | Sequence[str] | None` and `brief_ref: str | None`
   (default-valued additive extensions to the frozen signatures — back-compat, like
-  `models` / `max_concurrency`). The artifact is resolved at the TOP of the entry
-  point so timeout scaling, staging, and metadata all see the resolved content.
+  `models` / `max_concurrency`). `invoke_panel_request` consumes
+  `PanelRequest.artifact_ref` but deliberately does not define `PanelRequest.brief_ref`
+  in this contract; callers that need a custom brief use the direct `invoke_panel` or
+  `invoke_board` entry point. The artifact is resolved at the TOP of the entry point
+  so timeout scaling, staging, and metadata all see the resolved content.
 - **`_resolve_artifact(artifact, artifact_ref)`.** `artifact_ref is None` →
   `artifact or ""` (today's bytes, verbatim). A single path (a bare string OR a
   one-element sequence) returns the file content VERBATIM — no header — so
@@ -298,6 +301,60 @@ the caller passes a PATH and the runtime reads it.
   `_exec_leg`; Proof B injects `spawn=`) is untouched;
   `tests/test_advisor_board_ingestion.py` proves the new path is byte-transparent.
 
+## CTXFREEZE — Context references and panel reliability (#114)
+
+CTXFREEZE freezes the #114 public contract for downstream implementation and
+documentation phases. It does not claim that `artifact_ref` or `brief_ref` are true
+non-inlining modes: both are read-file-and-inline conveniences that keep bytes out
+of the caller context but still stage raw contents for each leg.
+
+- **Ingestion modes and precedence.** `artifact` is inline text. `artifact_ref` is a
+  file path, or ordered path sequence, whose contents replace `artifact` when both
+  are supplied. `brief_ref` is a file path used only by `invoke_panel` and
+  `invoke_board`; it replaces the generated review/advisory instruction file.
+  `context_refs` is the only true by-reference mode. `invoke_panel_request` threads
+  `PanelRequest.artifact_ref`, `PanelRequest.context_refs`,
+  `PanelRequest.context_refs_soft_warn`, and `PanelRequest.timeout_seconds_by_leg`;
+  `PanelRequest.brief_ref` is explicitly out of contract for this phase.
+- **True by-reference manifest.** `context_refs` appends a deterministic manifest to
+  the already-resolved artifact. Each entry is emitted in caller order and contains a
+  JSON-escaped absolute path, byte count, streamed SHA-256 digest, untrusted MIME
+  guess, untrusted extension hint, and optional best-effort PDF page count. Raw file
+  contents are not written into `review-bundle.md`, prompt text, or the manifest.
+- **Metadata sensitivity.** Absolute pathnames and hashes can disclose sensitive
+  project names, customer names, filenames, document structure, and content
+  fingerprints even when raw bytes are not inlined. Callers should treat the
+  manifest as metadata-bearing, not private-by-construction.
+- **Filesystem boundary.** Paths are interpreted relative to the current process
+  working directory when relative and are reported as `Path.resolve()` absolute
+  paths. Entries must be regular files at validation time; missing paths,
+  directories, devices, and other non-regular files fail closed by default. Symlinks
+  are followed only if their resolved target is a regular file under normal OS path
+  resolution. The runtime opens the file once to stream size/hash metadata and, for
+  PDF-looking files only, may reopen a bounded prefix for page counting; CTXIMPL owns
+  any stronger root jail or TOCTOU hardening.
+- **Provider and backing limits.** `context_refs` assumes the selected provider and
+  backing can access the same local filesystem path from the leg runtime. Remote,
+  sandboxed, or service-backed harnesses may not have local file access even when
+  the manifest validates on the caller host.
+- **Soft-warning opt-in.** Missing or unreadable `context_refs` raise `ValueError`
+  unless `context_refs_soft_warn=True`. Soft warning logs a warning and emits a
+  `MISSING` or `UNREADABLE` entry. The manifest instruction text remains strict:
+  a leg must not infer, guess, or fabricate unavailable contents.
+- **Output-boundary claim.** The frozen privacy claim is runtime non-inlining only:
+  referenced contents are absent from the staged bundle and prompt produced by this
+  runtime path. This is not a global DLP guarantee for provider logs, human-visible
+  outputs, handoffs, screenshots, shell commands, or tools the leg chooses to run
+  after reading a referenced file. A leg may disclose file contents after it
+  intentionally inspects a referenced path unless an output policy forbids that
+  disclosure.
+- **Reliability names.** Direct entry points accept `timeouts_by_leg`; `PanelRequest`
+  uses `timeout_seconds_by_leg`. Both feed the same per-leg override. Unset legs keep
+  input-scaled defaults. The codex and gemini CLI legs retry one fast soft-empty or
+  transient-stall result once, guarded by elapsed-time fraction; hard subprocess
+  timeouts return timeout status without retry. CTXRELY owns any follow-on reliability
+  split beyond these frozen names and retry/timeout invariants.
+
 ## ABDMODE — Purpose-derived default mode + advisory prompt hygiene · `panel_invoker.py` (#107)
 
 A board's PURPOSE now selects its default panel MODE automatically, so a domain

{phase_loop_runtime-0.3.0 → phase_loop_runtime-0.5.0}/src/phase_loop_runtime/cli.py

@@ -414,6 +414,16 @@ def build_parser() -> argparse.ArgumentParser:
                 action="store_true",
                 help="Consent to shape an unmanaged repo (no-op without this flag when no manifest exists yet).",
             )
+            sub.add_argument(
+                "--check-only",
+                action="store_true",
+                help=(
+                    "Run the conformance check only; never shape (ignores --adopt). "
+                    "On an adopted repo this is the verify pass. On an UN-ADOPTED repo "
+                    "it emits an explicit 'not adopted / nothing to verify' signal and "
+                    "exits non-zero (3), so a no-op is never mistaken for a pass."
+                ),
+            )
             sub.add_argument(
                 "--archetype",
                 action="append",
@@ -660,6 +670,28 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Emit the ledger state as JSON.",
     )
+    outside_agent_sub = subparsers.add_parser(
+        "outside-agent-preflight",
+        help="Emit advisory metadata-only outside-agent preflight evidence.",
+    )
+    outside_agent_sub.add_argument("submission_file", metavar="submission-file")
+    outside_agent_sub.add_argument("--output", help="Path to write advisory evidence JSON.")
+    outside_agent_validate_sub = subparsers.add_parser(
+        "outside-agent-validate",
+        help="Emit governed-pipeline outside-agent validation verdict JSON.",
+    )
+    outside_agent_validate_sub.add_argument("submission_file", metavar="submission-file")
+    outside_agent_validate_sub.add_argument(
+        "--output",
+        required=True,
+        help="Path to write governed-pipeline validation verdict JSON.",
+    )
+    outside_agent_validate_sub.add_argument(
+        "--submitted-ref",
+        action="append",
+        default=[],
+        help="Repo-relative ref submitted to governed-pipeline; may be repeated.",
+    )
     # DECOUPLE SL-1: dotfiles-domain commands are added here, only when a profile
     # plugin is installed/opted-in. A clean wheel registers none.
     _register_profile_commands(subparsers)
@@ -741,6 +773,10 @@ def _main(parser: argparse.ArgumentParser, args: argparse.Namespace, command: st
         return _run_train_command(parser=parser, args=args)
     if command == "train-status":
         return _run_train_status_command(parser=parser, args=args)
+    if command == "outside-agent-preflight":
+        return _outside_agent_preflight_command(args=args)
+    if command == "outside-agent-validate":
+        return _outside_agent_validate_command(args=args)
     if command == "docs-audit":
         from . import docs_audit
 
@@ -1118,6 +1154,78 @@ def _main(parser: argparse.ArgumentParser, args: argparse.Namespace, command: st
     return _run_returncode(snapshot, results)
 
 
+def _outside_agent_preflight_command(args: argparse.Namespace) -> int:
+    from .conformance.outside_agent_advisory import (
+        build_malformed_outside_agent_advisory_evidence,
+        build_outside_agent_advisory_evidence,
+        digest_outside_agent_submission_bytes,
+        serialize_outside_agent_advisory_evidence,
+    )
+
+    submission_path = Path(args.submission_file)
+    try:
+        raw = submission_path.read_bytes()
+    except OSError as exc:
+        evidence = build_malformed_outside_agent_advisory_evidence(
+            input_digest=digest_outside_agent_submission_bytes(str(submission_path).encode("utf-8")),
+            message=f"outside-agent submission JSON could not be read: {exc.__class__.__name__}",
+        )
+    else:
+        try:
+            submission = json.loads(raw.decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            evidence = build_malformed_outside_agent_advisory_evidence(
+                input_digest=digest_outside_agent_submission_bytes(raw),
+            )
+        else:
+            evidence = build_outside_agent_advisory_evidence(submission)
+
+    payload = serialize_outside_agent_advisory_evidence(evidence)
+    text = json.dumps(payload, indent=2, sort_keys=True) + "\n"
+    if args.output:
+        Path(args.output).write_text(text, encoding="utf-8")
+    print(text, end="")
+    return int(evidence.exit_code)
+
+
+def _outside_agent_validate_command(args: argparse.Namespace) -> int:
+    from .conformance.outside_agent_real import (
+        build_malformed_outside_agent_validation_verdict,
+        build_outside_agent_validation_verdict,
+    )
+    from .conformance.outside_agent_real_output import (
+        digest_outside_agent_validation_bytes,
+        serialize_outside_agent_validation_verdict,
+    )
+
+    submission_path = Path(args.submission_file)
+    try:
+        raw = submission_path.read_bytes()
+    except OSError as exc:
+        validation = build_malformed_outside_agent_validation_verdict(
+            input_digest=digest_outside_agent_validation_bytes(str(submission_path).encode("utf-8")),
+            message=f"outside-agent submission JSON could not be read: {exc.__class__.__name__}",
+        )
+    else:
+        try:
+            submission = json.loads(raw.decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            validation = build_malformed_outside_agent_validation_verdict(
+                input_digest=digest_outside_agent_validation_bytes(raw),
+            )
+        else:
+            validation = build_outside_agent_validation_verdict(
+                submission,
+                submitted_refs=tuple(args.submitted_ref or ()),
+            )
+
+    payload = serialize_outside_agent_validation_verdict(validation)
+    text = json.dumps(payload, indent=2, sort_keys=True) + "\n"
+    Path(args.output).write_text(text, encoding="utf-8")
+    print(text, end="")
+    return int(validation.exit_code)
+
+
 def _parse_lane_ir_override(parser: argparse.ArgumentParser, args: argparse.Namespace, command: str) -> tuple[str, ...]:
     raw = getattr(args, "allow_lane_ir_override", None)
     if raw is None:
@@ -1634,6 +1742,7 @@ def _consiliency_ingest_command(*, repo: Path, args: argparse.Namespace, as_json
     archetypes = tuple(dict.fromkeys(getattr(args, "archetype", None) or ()))
     modifiers = tuple(dict.fromkeys(getattr(args, "modifier", None) or ()))
     baseline_only = bool(getattr(args, "baseline_only", False))
+    check_only = bool(getattr(args, "check_only", False))
     if baseline_only and (archetypes or modifiers):
         print("phase-loop consiliency-ingest: --baseline-only is mutually exclusive with --archetype/--modifier", file=sys.stderr)
         return 2
@@ -1641,6 +1750,7 @@ def _consiliency_ingest_command(*, repo: Path, args: argparse.Namespace, as_json
         result = ingest(
             repo,
             adopt=bool(getattr(args, "adopt", False)),
+            check_only=check_only,
             mode="baseline-only" if baseline_only else "archetyped",
             archetypes=archetypes,
             modifiers=modifiers,
@@ -1658,6 +1768,8 @@ def _consiliency_ingest_command(*, repo: Path, args: argparse.Namespace, as_json
         print(f"phase-loop consiliency-ingest: {result.mode} {result.manifest_path}")
         if result.mode == "skipped":
             print("  no .consiliency/manifest and --adopt was not passed; repo left untouched")
+        if result.mode == "not-adopted":
+            print("  NOT ADOPTED: no .consiliency/manifest -- nothing to verify (a no-op is not a pass)")
         if result.mode == "shape":
             created = (result.scaffold or {}).get("created_paths", [])
             print(f"  scaffolded {len(created)} doc(s); proposed governed_set entries: {len(result.governed_set)}")
@@ -1665,6 +1777,19 @@ def _consiliency_ingest_command(*, repo: Path, args: argparse.Namespace, as_json
             print(f"  gate scan: {result.gate_scan.get('status')}")
             for finding in result.findings:
                 print(f"  finding: {finding.get('code')} ({finding.get('path')})")
+    # --check-only makes the exit code verdict-significant, so a pre-PR actor is
+    # never misled into reading a no-op OR a failing verify as a pass:
+    #   3 -> not adopted / nothing to verify (distinct from a pass)
+    #   1 -> adopted but the gate scan is BLOCKED (a real conformance failure)
+    #   0 -> adopted + verify clean (warn stays 0: soft by default)
+    # 2 remains the usage-error code. The plain (non --check-only) path is
+    # UNCHANGED -- it keeps returning 0 exactly as before (see report note on
+    # the pre-existing blocked->0 gap on the plain command).
+    if check_only:
+        if result.mode == "not-adopted":
+            return 3
+        if result.gate_scan is not None and result.gate_scan.get("status") == "blocked":
+            return 1
     return 0
 
 

{phase_loop_runtime-0.3.0 → phase_loop_runtime-0.5.0}/src/phase_loop_runtime/closeout.py

@@ -15,9 +15,9 @@ from .closeout_validators import (
 from .models import (
     PIPELINE_CLOSEOUT_OUTCOMES,
     PIPELINE_CLOSEOUT_SCHEMA,
-    PIPELINE_PROTECTED_SOURCE_CATEGORIES,
     PIPELINE_PROTECTED_SOURCE_LEGACY_ROLES,
     PIPELINE_PROTECTED_SOURCE_ROLES,
+    protected_source_categories,
     SPEC_DELTA_CLOSEOUT_SCHEMA,
     SPEC_DELTA_DECISIONS,
     DirtyPathClassification,
@@ -625,7 +625,7 @@ def phase_loop_closeout_diagnostic(payload: Mapping[str, Any] | None) -> dict[st
                 return {"kind": "malformed_closeout", "message": "closeout source_bundle.protected_sources entries must be objects"}
             category = item.get("category")
             role = item.get("role")
-            if category not in PIPELINE_PROTECTED_SOURCE_CATEGORIES:
+            if category not in protected_source_categories():
                 return {"kind": "malformed_closeout", "message": "closeout source_bundle protected source has invalid category"}
             if role is not None and role not in PIPELINE_PROTECTED_SOURCE_ROLES and role not in PIPELINE_PROTECTED_SOURCE_LEGACY_ROLES:
                 return {"kind": "malformed_closeout", "message": "closeout source_bundle protected source has invalid role"}

phase_loop_runtime-0.5.0/src/phase_loop_runtime/conformance/__init__.py

@@ -0,0 +1,79 @@
+"""``phase_loop_runtime.conformance`` -- the named conformance surface.
+
+This package preserves the existing public ``.consiliency/`` conformance
+imports while providing a namespace for outside-agent contract pin helpers.
+"""
+from __future__ import annotations
+
+from ..consiliency_gates import (
+    CONSILIENCY_GATES_ENV,
+    CONSILIENCY_GATES_MODES,
+    DEFAULT_CONSILIENCY_GATES_MODE,
+    resolve_consiliency_gates_mode,
+    scan_consiliency_gates,
+)
+from ..consiliency_ingest import evaluate_governance_scope
+from ..git_discipline import evaluate_git_discipline, self_heal_partition
+from .outside_agent_core import (
+    OutsideAgentBlocker,
+    OutsideAgentConformanceVerdict,
+    OutsideAgentEvidenceRef,
+    OutsideAgentSubmissionKind,
+    OutsideAgentVerdictStatus,
+    validate_outside_agent_submission,
+)
+from .outside_agent_advisory import (
+    OutsideAgentAdvisoryEvidence,
+    OutsideAgentAdvisoryExitCode,
+    build_outside_agent_advisory_evidence,
+    serialize_outside_agent_advisory_evidence,
+)
+from .outside_agent_imports import (
+    OutsideAgentContractError,
+    load_outside_agent_contract_pin,
+)
+from .outside_agent_pin import (
+    EXPECTED_OUTSIDE_AGENT_CONTRACT_PIN,
+    OutsideAgentContractPin,
+)
+from .outside_agent_real import (
+    OutsideAgentSubmittedRef,
+    OutsideAgentValidationExitCode,
+    OutsideAgentValidationVerdict,
+    build_outside_agent_validation_verdict,
+)
+from .outside_agent_real_output import (
+    digest_outside_agent_validation_bytes,
+    serialize_outside_agent_validation_verdict,
+)
+
+__all__ = [
+    "scan_consiliency_gates",
+    "resolve_consiliency_gates_mode",
+    "CONSILIENCY_GATES_ENV",
+    "CONSILIENCY_GATES_MODES",
+    "DEFAULT_CONSILIENCY_GATES_MODE",
+    "evaluate_git_discipline",
+    "self_heal_partition",
+    "evaluate_governance_scope",
+    "OutsideAgentBlocker",
+    "OutsideAgentConformanceVerdict",
+    "OutsideAgentEvidenceRef",
+    "OutsideAgentSubmissionKind",
+    "OutsideAgentVerdictStatus",
+    "validate_outside_agent_submission",
+    "OutsideAgentAdvisoryEvidence",
+    "OutsideAgentAdvisoryExitCode",
+    "build_outside_agent_advisory_evidence",
+    "serialize_outside_agent_advisory_evidence",
+    "OutsideAgentContractError",
+    "load_outside_agent_contract_pin",
+    "EXPECTED_OUTSIDE_AGENT_CONTRACT_PIN",
+    "OutsideAgentContractPin",
+    "OutsideAgentSubmittedRef",
+    "OutsideAgentValidationExitCode",
+    "OutsideAgentValidationVerdict",
+    "build_outside_agent_validation_verdict",
+    "digest_outside_agent_validation_bytes",
+    "serialize_outside_agent_validation_verdict",
+]