From 3d2ad29e34261ea57f1bbeea0c47008d2ee9192a Mon Sep 17 00:00:00 2001 From: MrScripty Date: Thu, 12 Nov 2026 07:20:56 -0700 Subject: [PATCH 1/4] test(engine): align stale tests with interface 48 and checkout reconciliation Six engine tests have failed on main since 22 October, when two changes landed without the tests that depend on them being updated: - Interface 48 (ad564433). Four publication tests asserted the literal "interface 47;" in the server instructions, and two contract examples still carried interface_version 47. The assertion now reads the number from the interface the server under test serves, so it cannot go stale again, and the examples say 48. - Publication checkout reconciliation (8c5a4ad4). The create-and-retire apply test still asserted that apply leaves the working tree untouched. It now asserts the documented behaviour: HEAD, index and worktree present the published candidate and no other local difference exists. No production code changes. The suite-input manifest is regenerated; it was already stale on main because 5bce3110 added files without refreshing it. Co-Authored-By: Claude Fable 5.2 --- .../generated/suite-inputs.json | 6 +-- .../contracts/examples/a1-examples.json | 4 +- tools/standards_engine/tests/test_analysis.py | 42 ++++++++++++++++++- .../tests/test_consumer_publication.py | 13 +++++- 4 files changed, 57 insertions(+), 8 deletions(-) diff --git a/evaluation/standards-effectiveness/generated/suite-inputs.json b/evaluation/standards-effectiveness/generated/suite-inputs.json index d12e6834..58420f4d 100644 --- a/evaluation/standards-effectiveness/generated/suite-inputs.json +++ b/evaluation/standards-effectiveness/generated/suite-inputs.json @@ -7405,7 +7405,7 @@ ] }, { - "digest": "sha256:489fea805dbfd6f84bcb28374b467da192d56243100c0a58d568d9acf6180e08", + "digest": "sha256:146231132e8fbff19b5d917c1268bb75a0195cff4478d0e44df6bf04b8ba6aa2", "path": "tools/standards_engine/contracts/examples/a1-examples.json", "state": "present", "uses": [ @@ -7875,7 +7875,7 @@ ] }, { - "digest": "sha256:7f51e403f03f5c57be8b1ca5736a79bcf139c87dd9eb4703ce3f7e59f1ba3d01", + "digest": "sha256:30eec6a6c472938048821b5669d17e054aa7cdee637647961b4012a380245e62", "path": "tools/standards_engine/tests/test_analysis.py", "state": "present", "uses": [ @@ -14116,7 +14116,7 @@ "path": "evaluation/standards-effectiveness/suite-registry.toml" }, "repository_index": { - "digest": "sha256:25f5d13e9650e10c5bcc198f50ea81aa00f90799ca3f9ba2a5a433a658262229", + "digest": "sha256:96dd89639c5b1a45d6c6692e969cea93338efdd3e5604fb2c2d30e6cfe254fd7", "uses": [ { "check": "python-package-contract", diff --git a/tools/standards_engine/contracts/examples/a1-examples.json b/tools/standards_engine/contracts/examples/a1-examples.json index a697ac1f..1f256f60 100644 --- a/tools/standards_engine/contracts/examples/a1-examples.json +++ b/tools/standards_engine/contracts/examples/a1-examples.json @@ -1274,7 +1274,7 @@ "value": { "kind": "input-contract-result", "purpose": "application", - "interface_version": 47, + "interface_version": 48, "catalog_digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "operation": "runtime_info", "root": "RuntimeInfoCall", @@ -1420,7 +1420,7 @@ "value": { "kind": "output-contract-result", "purpose": "authoring", - "interface_version": 47, + "interface_version": 48, "catalog_digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "operation": "review", "dialect": "https://json-schema.org/draft/2020-12/schema", diff --git a/tools/standards_engine/tests/test_analysis.py b/tools/standards_engine/tests/test_analysis.py index 0eeaf032..0ae8a9e6 100644 --- a/tools/standards_engine/tests/test_analysis.py +++ b/tools/standards_engine/tests/test_analysis.py @@ -687,8 +687,39 @@ def apply_ready(readiness_id: str) -> ProposalApplication: } ) ) + # Apply advances this unchanged main checkout to its publication. + self.assertEqual(applied.checkout.status, "current") return engine._authoring.read_application(applied.application.id) + def assert_checkout_presents( + application: ProposalApplication, + present: tuple[str, ...], + absent: tuple[str, ...] = (), + ) -> None: + # Interface 47: HEAD, index and worktree all present the exact + # published candidate, and no other local difference appears. + self.assertEqual( + git_output(repository, ("rev-parse", "HEAD")).strip(), + application.candidate.oid.encode("ascii"), + ) + for path in present: + self.assertEqual( + (repository / path).read_bytes(), + engine._repository.read_file( + application.candidate, RepositoryPath.parse(path) + ), + path, + ) + for path in absent: + self.assertFalse((repository / path).exists(), path) + self.assertEqual( + git_output( + repository, + ("status", "--porcelain=v1", "--untracked-files=all"), + ), + b"", + ) + def assert_commit( application: ProposalApplication, revision: ProposalRevision, @@ -798,7 +829,10 @@ def assert_commit( impact_path: "100644", }, ) - self.assertFalse((repository / standard_path).exists()) + assert_checkout_presents( + create_application, + (standard_path, policy_path, impact_path), + ) facade.close() engine = StandardsEngine.open_repository( @@ -933,7 +967,11 @@ def assert_commit( ) self.assertIn(b"[[tombstone]]", retired_policy) self.assertNotIn(b"[[policy_unit]]", retired_policy) - self.assertFalse((repository / standard_path).exists()) + assert_checkout_presents( + retire_application, + (policy_path,), + absent=(standard_path, impact_path), + ) facade.close() engine = StandardsEngine.open_repository( diff --git a/tools/standards_engine/tests/test_consumer_publication.py b/tools/standards_engine/tests/test_consumer_publication.py index 43021335..b5d05cc0 100644 --- a/tools/standards_engine/tests/test_consumer_publication.py +++ b/tools/standards_engine/tests/test_consumer_publication.py @@ -11,13 +11,23 @@ import subprocess import sys import tempfile +import tomllib import unittest +from tools.standards_engine.standards_engine.tools import INTERFACE_CONTRACT from tools.standards_engine.tests.test_agent_workflow import ROOT, decisions, evidence, prepare_repository from tools.standards_engine.tests import test_proposal_consumers as fixtures from tools.standards_engine.tests.test_proposal_consumers import registration +def installed_interface_version(root): + # The server announces the interface declared by the repository it serves. + # Read that declaration instead of repeating a number that each interface + # edition would otherwise leave stale here. + with (root / INTERFACE_CONTRACT).open('rb') as source: + return tomllib.load(source)['interface_schema_version'] + + class ConsumerPublicationTest(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory(prefix='consumer-publication-') @@ -43,7 +53,8 @@ def rpc(self, method, params, purpose='authoring'): self.assertEqual(process.returncode,0,process.stderr) self.assertEqual(process.stderr,'') responses={row['id']:row for row in map(json.loads,process.stdout.splitlines())} - self.assertIn('interface 47;',responses[1]['result']['instructions']) + self.assertIn(f'interface {installed_interface_version(self.root)};', + responses[1]['result']['instructions']) return responses[2] def call(self,name,arguments,purpose='authoring',error=False): From f2984a3665efa7128427f380ada550b436f3c470 Mon Sep 17 00:00:00 2001 From: MrScripty Date: Thu, 12 Nov 2026 07:21:22 -0700 Subject: [PATCH 2/4] perf(snapshots): audit the store once per process, not on every open The MCP server opens the snapshot store for each tool call, and every open of an existing store ran PRAGMA integrity_check and foreign_key_check over the whole file. On a 282 MB store that is about 0.6 s added to every route, read and related call, growing with the file. The full audit now runs at most once per process for each store file, identified by device and inode. It still runs on the first open in every process, throughout a version 1 migration, and for a file put in place under a different inode. Application id, schema version and exact schema checks still run on every open. Measured on a copy of that store, five consecutive opens in one process go from about 0.6 s each to 0.6 s for the first and under 1 ms for the rest. Known limits, documented in the snapshots README: a one-shot CLI call is a new process and still audits; a store deleted and recreated in place can reuse its inode on ext4 and is then not audited again by a server that is already running. Tests cover one audit for two opens, a replaced file, a corrupt replacement, the checks that stay on every open, a fresh process rejecting a corrupted file, migration keeping all of its audits, and the server auditing once across several tool calls. Co-Authored-By: Claude Fable 5.2 --- .../generated/suite-inputs.json | 6 +- tools/standards_engine/PURPOSE-SEPARATION.md | 16 +- tools/standards_engine/README.md | 4 + .../tests/test_storage_lifecycle_transport.py | 116 ++++++++--- tools/standards_snapshots/README.md | 33 +++- .../standards_snapshots/store.py | 54 ++++- .../tests/test_storage_lifecycle.py | 184 ++++++++++++++++-- 7 files changed, 354 insertions(+), 59 deletions(-) diff --git a/evaluation/standards-effectiveness/generated/suite-inputs.json b/evaluation/standards-effectiveness/generated/suite-inputs.json index 58420f4d..9dbde56a 100644 --- a/evaluation/standards-effectiveness/generated/suite-inputs.json +++ b/evaluation/standards-effectiveness/generated/suite-inputs.json @@ -7347,7 +7347,7 @@ ] }, { - "digest": "sha256:8d8859b36d951bbf7a747da81d597df19b07b6653f1e36acc48b4b131b90c0a8", + "digest": "sha256:c85b4e2d525e7d644261658b19e35b815e86f6386754d327f56de5bc8be52caa", "path": "tools/standards_engine/README.md", "state": "present", "uses": [ @@ -8344,7 +8344,7 @@ ] }, { - "digest": "sha256:828be47647e4332067893b79a508e85ed65ff1d524c41daf8f09fa41f6b7d2a2", + "digest": "sha256:e6f3adf5543fad7cbd24b31b68b21d08029e542e11d80d2899d30b2ced682452", "path": "tools/standards_snapshots/README.md", "state": "present", "uses": [ @@ -8441,7 +8441,7 @@ ] }, { - "digest": "sha256:bda178630b8226af0de5c42a7da6290ace2ed1745e3d2a99057deb0bae6ac617", + "digest": "sha256:6853039f09ef90b9d4ba9f54e4df7050b13b0a1941764af95250b44f7237ecae", "path": "tools/standards_snapshots/standards_snapshots/store.py", "state": "present", "uses": [ diff --git a/tools/standards_engine/PURPOSE-SEPARATION.md b/tools/standards_engine/PURPOSE-SEPARATION.md index b112edf0..02e66413 100644 --- a/tools/standards_engine/PURPOSE-SEPARATION.md +++ b/tools/standards_engine/PURPOSE-SEPARATION.md @@ -124,9 +124,14 @@ two-entry and 32 MiB accounted-retention limit shared by snapshot and draft projection entries. Snapshot keys contain the exact verified captured paths, bytes and source revision, plus the installed compiler function. Python dictionary equality distinguishes hash collisions. Each new operation -opens and validates its store, checks snapshot lifecycle and verifies complete -content identity before lookup. Missing, quarantined, purged, replaced or corrupt -storage therefore remains observable. Equal verified inputs may share pure +opens its store, checks its application, version and exact schema, checks snapshot +lifecycle and verifies complete content identity before lookup. Missing, +quarantined, purged or replaced storage, and content that no longer matches its +identity, therefore remain observable. The store's complete SQLite +integrity/foreign-key audit is not repeated by every operation: a process runs it +on its first open of a store file, as described under +[Snapshot admission](../standards_snapshots/README.md#admission-and-maintenance-work). +Equal verified inputs may share pure compilation even when obtained from distinct store roots; store-specific handles, access checks and result envelopes remain fresh. No store facts enter the cache. @@ -185,8 +190,9 @@ Review, candidate verification, application and recovery retain their existing fresh replay paths. New snapshot capture retains both independent compiler passes. Main advancement affects new captures, never the base of an existing draft. Old explicit revisions retain historical meaning and can have live stale status. -Corruption, quarantine, purge or missing/replaced stores reject before projection -reuse. Server restart reconstructs cold, and close releases both entry kinds. +Stored content that fails validation, quarantine, purge or missing/replaced stores +reject before projection reuse. Server restart reconstructs cold and repeats the +store's complete SQLite audit; close releases both entry kinds. ### Incremental successor construction diff --git a/tools/standards_engine/README.md b/tools/standards_engine/README.md index 3e0b3fd7..85f52a8d 100644 --- a/tools/standards_engine/README.md +++ b/tools/standards_engine/README.md @@ -336,6 +336,10 @@ The process-owned compilation cache also retains exact captured-content identity proofs. Identity and compilation for one capture share one LRU entry and the existing byte budget. The Snapshot codec still defines identity, and every read reloads actual bytes, verifies file integrity and checks the stored identity and current lifecycle. +These per-read checks are separate from the store's complete SQLite +integrity/foreign-key audit, which a process runs on its first open of a store file +and not on each store-backed call; see +[Snapshot admission](../standards_snapshots/README.md#admission-and-maintenance-work). Focused authoring operations reuse canonical revision decoding through `ProposalMaterials`; the single record is released on success or exceptional exit. diff --git a/tools/standards_engine/tests/test_storage_lifecycle_transport.py b/tools/standards_engine/tests/test_storage_lifecycle_transport.py index a9b5eb47..0ff707b7 100644 --- a/tools/standards_engine/tests/test_storage_lifecycle_transport.py +++ b/tools/standards_engine/tests/test_storage_lifecycle_transport.py @@ -1,5 +1,8 @@ """Cold MCP reads coexist with a reserved writer only when no purge is due. +One server process audits its store once, on its first call; a newly started +process audits again and still rejects a corrupt store. + The fixture owns its database, evidence and processes. Publication, authorization and interpreter timing are not simulated; no production store is accessed. """ @@ -7,19 +10,27 @@ import json import os +import shutil import sqlite3 import subprocess import sys import time import unittest from contextlib import closing +from pathlib import Path +from unittest import mock +from tools.standards_engine.standards_engine.mcp import MCPServer from tools.standards_engine.tests import test_agent_interaction_transport as transport +from tools.standards_engine.tests.test_mcp import initialize, request from tools.standards_engine.tests.test_route_content import known_assertions from tools.standards_snapshots.standards_snapshots import ( AggregateChild, AggregateRecord, AggregateRoot, ChildHandle, SnapshotError, SnapshotId, SnapshotModule, ) +from tools.standards_snapshots.standards_snapshots import store as snapshot_store + +AUDIT_STATEMENTS = ('PRAGMA integrity_check', 'PRAGMA foreign_key_check') class StorageLifecycleTransportTest(unittest.TestCase): @@ -39,6 +50,85 @@ def call(self, purpose, operation, arguments, *, rejected=False): self, purpose, operation, arguments, rejected=rejected, delivery='on-demand', ) + def cold_open_failure(self): + """Run one cold authoring read whose store open fails; return its private stderr.""" + # Open-time failure retains the existing MCP private-stderr + # boundary (no structured result), not an invented tool outcome. + messages = [ + {'jsonrpc': '2.0', 'id': 1, 'method': 'initialize', 'params': { + 'protocolVersion': '2025-11-25', 'capabilities': {}, + 'clientInfo': {'name': 'storage-open-fixture', 'version': '1'}}}, + {'jsonrpc': '2.0', 'method': 'notifications/initialized'}, + {'jsonrpc': '2.0', 'id': 2, 'method': 'tools/call', 'params': { + 'name': 'read', 'arguments': {'snapshot': self.snapshot, 'target': 'core'}}}, + ] + process = subprocess.run( + [sys.executable, '-P', '-m', 'tools.standards_engine.standards_engine.mcp', + '--repo-root', str(self.root), '--purpose', 'authoring', + '--output-schemas', 'on-demand'], + env={**os.environ, 'PYTHONPATH': str(transport.fixture.ROOT)}, + input=''.join(json.dumps(message) + '\n' for message in messages), + text=True, capture_output=True, timeout=90, + ) + self.assertEqual(process.returncode, 0, process.stderr) + failed = next(json.loads(line)['result'] for line in process.stdout.splitlines() + if json.loads(line).get('id') == 2) + self.assertTrue(failed['isError']) + self.assertNotIn('structuredContent', failed) + self.assertIn('Engine invocation failed', failed['content'][0]['text']) + return process.stderr + + def test_one_server_process_audits_its_store_once_across_calls(self): + # The fixture built this store inside the test process. Discard that + # record so the server below starts as a newly launched process does. + with snapshot_store._AUDITED_FILES_LOCK: + snapshot_store._AUDITED_FILES.clear() + opens = [] + connect = sqlite3.connect + + def traced_connect(database, *arguments, **options): + connection = connect(database, *arguments, **options) + if Path(database).resolve() == self.path.resolve(): + opens.append([]) + connection.set_trace_callback(opens[-1].append) + return connection + + server = MCPServer(self.root, purpose='application') + self.addCleanup(server.close) + initialize(server) + arguments = {'snapshot': self.snapshot, 'target': 'core'} + with mock.patch.object(snapshot_store.sqlite3, 'connect', traced_connect): + results = [ + server.dispatch(request('tools/call', {'name': 'read', 'arguments': arguments}, + identifier))['result'] + for identifier in (2, 3, 4) + ] + for result in results: + self.assertFalse(result['isError'], result) + self.assertEqual(result['structuredContent']['content'], + transport.fixture.PurposeTransportTest.expected) + # Every call still opens and closes its own store connection. + self.assertEqual(len(opens), 3) + self.assertEqual([[statement for statement in statements if statement in AUDIT_STATEMENTS] + for statements in opens], [list(AUDIT_STATEMENTS), [], []]) + for statements in opens: + self.assertIn('PRAGMA application_id', statements) + self.assertIn('PRAGMA user_version', statements) + self.assertTrue(any('FROM sqlite_schema' in statement for statement in statements)) + + def test_cold_server_process_rejects_a_corrupt_store_on_its_first_call(self): + retained = self.path.with_name('retained-valid-store.sqlite3') + shutil.copyfile(self.path, retained) + try: + with closing(sqlite3.connect(self.path, isolation_level=None)) as corruptor: + corruptor.execute( + "INSERT INTO content_files VALUES ('missing', 'a', X'', 0, 'digest')") + self.assertIn('SNAPSHOT_STORE.FOREIGN_KEY_FAILURE', self.cold_open_failure()) + finally: + os.replace(retained, self.path) + recovered = self.call('authoring', 'read', {'snapshot': self.snapshot, 'target': 'core'}) + self.assertEqual(recovered['content'], transport.fixture.PurposeTransportTest.expected) + def test_cold_agent_observations_match_while_another_process_holds_writer(self): cases = [ ('read', {'snapshot': self.snapshot, 'target': 'core'}), @@ -82,31 +172,7 @@ def test_cold_due_maintenance_keeps_busy_then_expires_all_dependents_atomically( with closing(sqlite3.connect(self.path, isolation_level=None)) as writer: writer.execute('BEGIN IMMEDIATE') try: - # Open-time failure retains the existing MCP private-stderr - # boundary (no structured result), not an invented tool outcome. - messages = [ - {'jsonrpc': '2.0', 'id': 1, 'method': 'initialize', 'params': { - 'protocolVersion': '2025-11-25', 'capabilities': {}, - 'clientInfo': {'name': 'storage-busy-fixture', 'version': '1'}}}, - {'jsonrpc': '2.0', 'method': 'notifications/initialized'}, - {'jsonrpc': '2.0', 'id': 2, 'method': 'tools/call', 'params': { - 'name': 'read', 'arguments': {'snapshot': self.snapshot, 'target': 'core'}}}, - ] - process = subprocess.run( - [sys.executable, '-P', '-m', 'tools.standards_engine.standards_engine.mcp', - '--repo-root', str(self.root), '--purpose', 'authoring', - '--output-schemas', 'on-demand'], - env={**os.environ, 'PYTHONPATH': str(transport.fixture.ROOT)}, - input=''.join(json.dumps(message) + '\n' for message in messages), - text=True, capture_output=True, timeout=90, - ) - self.assertEqual(process.returncode, 0, process.stderr) - self.assertIn('SNAPSHOT_STORE.BUSY', process.stderr) - failed = next(json.loads(line)['result'] for line in process.stdout.splitlines() - if json.loads(line).get('id') == 2) - self.assertTrue(failed['isError']) - self.assertNotIn('structuredContent', failed) - self.assertIn('Engine invocation failed', failed['content'][0]['text']) + self.assertIn('SNAPSHOT_STORE.BUSY', self.cold_open_failure()) self.assertIsNotNone(writer.execute( 'SELECT 1 FROM snapshot_roots WHERE snapshot_id = ?', (str(expired),) ).fetchone()) diff --git a/tools/standards_snapshots/README.md b/tools/standards_snapshots/README.md index a1809843..0d56ee42 100644 --- a/tools/standards_snapshots/README.md +++ b/tools/standards_snapshots/README.md @@ -53,18 +53,33 @@ No identity domain, store format or persisted representation changes. ## Admission and maintenance work -Each open of an existing current-schema database authenticates the application, -exact schema, and complete SQLite integrity/foreign-key state **before** persistent -configuration. Configuration is followed by the existing exact schema check. The -same full audit is not repeated for a store admitted at the current schema version. -This is a point-in-time audit on every open, not cached proof that the database can -never change. Selected content and aggregate reads retain their ordinary checks. +Each open of an existing current-schema database authenticates the application +and exact schema **before** persistent configuration. Configuration is followed by +the existing exact schema check. Those checks run on every open. -New initialization keeps its final integrity audit and owned-file cleanup on failure. +The complete SQLite integrity/foreign-key audit runs once per process for each +store file. A process's first open of a file audits it before persistent +configuration. Later opens of the same file by that process omit only this audit. +The process remembers a passed audit in memory, by the file's device and inode, and +only after that open succeeded; nothing is persisted. A new process audits again, +and so does a file moved into place under a different inode. To audit a store +again, open it from a new process. `maintain` purges expired roots; it does not run +this audit. + +The audit is a point-in-time observation, not proof that the database stays valid. +Damage that appears after a process's audit is not reported by that process's later +opens. A file deleted and then recreated outside this package can receive the +audited file's inode number, and that process does not audit it; replace a store by +renaming a complete file into place, or restart the process. Selected content and +aggregate reads retain their ordinary checks on every call. + +New initialization keeps its final integrity audit and owned-file cleanup on failure; +that audit is the creating process's audit of the new file. A store admitted as v1 keeps the pre-configuration audit, transaction-guarded -pre/post-migration audits, and final destination audit. The final audit also applies +pre/post-migration audits, and final destination audit, even when the process +audited the same file earlier. The final audit also applies when another opener finishes migration before this opener prepares the schema. -No integrity policy, SQLite profile, supported migration or stored format changes. +No SQLite profile, supported migration or stored format changes. Maintenance remains synchronous at the same module call sites. It first performs a short-lived existence read for quarantined roots whose deadline is at or before the diff --git a/tools/standards_snapshots/standards_snapshots/store.py b/tools/standards_snapshots/standards_snapshots/store.py index 9b42f2ac..8c1ec836 100644 --- a/tools/standards_snapshots/standards_snapshots/store.py +++ b/tools/standards_snapshots/standards_snapshots/store.py @@ -5,6 +5,7 @@ import os import sqlite3 import stat +import threading from collections.abc import Iterator from contextlib import closing, contextmanager from functools import lru_cache @@ -35,6 +36,25 @@ USER_VERSION = 2 BUSY_TIMEOUT_MS = 5_000 +# Device and inode of every store file whose complete SQLite integrity and +# foreign-key audit has passed in this process. A later open of the same file +# keeps every other admission check and omits only that audit pair. The record +# is never persisted: each new process audits again, and a file put in place +# under a different inode has no record. It is a point-in-time observation of +# one file, not proof that another process has left the file unchanged. +_AUDITED_FILES: set[tuple[int, int]] = set() +_AUDITED_FILES_LOCK = threading.Lock() + + +def _audit_recorded(identity: tuple[int, int]) -> bool: + with _AUDITED_FILES_LOCK: + return identity in _AUDITED_FILES + + +def _record_audit(identity: tuple[int, int]) -> None: + with _AUDITED_FILES_LOCK: + _AUDITED_FILES.add(identity) + def _root_reference(value: object, description: str) -> None: if type(value) is not str or not value: @@ -274,6 +294,7 @@ def __init__(self, path: Path) -> None: "SNAPSHOT_STORE.UNSUPPORTED_PATH", "SQLite path must be one regular non-symlink file", ) + identity = (observed.st_dev, observed.st_ino) else: path.parent.mkdir(mode=0o700, parents=True, exist_ok=True) flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL @@ -281,7 +302,7 @@ def __init__(self, path: Path) -> None: try: descriptor = os.open(path, flags, 0o600) observed = os.fstat(descriptor) - created_identity = (observed.st_dev, observed.st_ino) + identity = created_identity = (observed.st_dev, observed.st_ino) os.close(descriptor) except OSError as error: raise unavailable("SNAPSHOT_STORE.UNAVAILABLE", str(error)) from error @@ -292,11 +313,18 @@ def __init__(self, path: Path) -> None: ) self._connection = connection self._connection.enable_load_extension(False) + # SQLite has opened whichever file the path named at that moment. + # An audit is reused, and afterwards recorded, only for a path that + # still names the file observed before the connection was made. + same_file = self._path_identity() == identity if existed: - admitted_version = self._verify_existing_authority() + admitted_version = self._verify_existing_authority( + audited=same_file and _audit_recorded(identity) + ) self._configure() self._prepare_existing_schema() - # Current stores were fully audited before configuration. A v1 + # Current stores were fully audited before configuration, in + # this open or an earlier one in this process. A v1 # admission still needs the final destination audit, including # when another opener completed migration in the meantime. if admitted_version != USER_VERSION: @@ -305,6 +333,8 @@ def __init__(self, path: Path) -> None: self._configure() self._initialize_schema() self._verify_integrity() + if same_file: + _record_audit(identity) except Exception as error: self._cleanup_failed_open(connection, created_identity) if isinstance(error, SnapshotError): @@ -318,6 +348,13 @@ def __init__(self, path: Path) -> None: def close(self) -> None: self._connection.close() + def _path_identity(self) -> tuple[int, int] | None: + try: + observed = self.path.lstat() + except OSError: + return None + return (observed.st_dev, observed.st_ino) + def _cleanup_failed_open( self, connection: sqlite3.Connection | None, @@ -1047,8 +1084,12 @@ def _prepare_existing_schema(self) -> None: self._migrate_version_one() self._verify_schema() - def _verify_existing_authority(self) -> int: - """Authenticate before configuration and return the admitted schema version.""" + def _verify_existing_authority(self, *, audited: bool) -> int: + """Authenticate before configuration and return the admitted schema version. + + ``audited`` reports that this process already completed the full audit + of this exact current-schema file. It never shortens a v1 admission. + """ application_id = self._connection.execute("PRAGMA application_id").fetchone()[0] user_version = self._connection.execute("PRAGMA user_version").fetchone()[0] if application_id != APPLICATION_ID: @@ -1071,7 +1112,8 @@ def _verify_existing_authority(self) -> int: f"expected schema version 1 or {USER_VERSION}, observed {user_version}", ) self._verify_schema() - self._verify_integrity() + if not audited: + self._verify_integrity() return user_version def _migrate_version_one(self) -> None: diff --git a/tools/standards_snapshots/tests/test_storage_lifecycle.py b/tools/standards_snapshots/tests/test_storage_lifecycle.py index 66afbafd..ce7edb5e 100644 --- a/tools/standards_snapshots/tests/test_storage_lifecycle.py +++ b/tools/standards_snapshots/tests/test_storage_lifecycle.py @@ -2,26 +2,67 @@ No-work observations must not request a writer. A positive probe is only a hint: transactions still select the current due set and own all deletion effects. + +One process runs the complete integrity/foreign-key audit of a store file once. +Later opens of that file keep the application, version and exact schema checks. """ from __future__ import annotations +import os +import shutil import sqlite3 +import subprocess +import sys import tempfile import unittest from contextlib import closing from pathlib import Path from typing import Callable +from unittest import mock from tools.standards_snapshots.standards_snapshots import ( AggregateChild, AggregateRecord, AggregateRoot, ChildHandle, FindAggregateRootsRequest, FindSnapshotsRequest, SnapshotError, SnapshotModule, ) +from tools.standards_snapshots.standards_snapshots import store as store_module from tools.standards_snapshots.standards_snapshots.store import SQLiteSnapshotStore from tools.standards_snapshots.tests.test_module import capture from tools.standards_snapshots.tests.test_store import ( _populated_version_one_store, _version_one_rows, ) +ROOT = Path(__file__).resolve().parents[3] + +# A separate interpreter has no audit record. It reports the admission outcome +# of the ordinary module open path for one existing store file. +_COLD_OPEN = """ +import sys +from pathlib import Path +from tools.standards_snapshots.standards_snapshots import SnapshotError, SnapshotModule +try: + SnapshotModule.open(Path(sys.argv[1])).close() +except SnapshotError as error: + print(error.failure.code) +else: + print('admitted') +""" + + +def _begin_as_new_process() -> None: + """Discard this process's audit record, as a newly started process has none.""" + with store_module._AUDITED_FILES_LOCK: + store_module._AUDITED_FILES.clear() + + +def _file_identity(path: Path) -> tuple[int, int]: + observed = path.lstat() + return observed.st_dev, observed.st_ino + + +def _violate_foreign_key(path: Path) -> None: + with closing(sqlite3.connect(path, isolation_level=None)) as corruptor: + corruptor.execute("INSERT INTO content_files VALUES ('missing', 'a', X'', 0, 'digest')") + class _ObservedAdmissionStore(SQLiteSnapshotStore): """Record proof phases while running the unchanged real proof implementations.""" @@ -74,6 +115,25 @@ def setUp(self): self.addCleanup(directory.cleanup) self.path = Path(directory.name) / 'snapshots.sqlite3' self.now = 2_000_000_000 + # Audit expectations must not depend on stores opened by earlier tests, + # whose removed files can lend their inode numbers to these fixtures. + _begin_as_new_process() + + def events(self, path=None): + opened = _ObservedAdmissionStore(path or self.path) + try: + return opened.admission_events + finally: + opened.close() + + def cold_open(self, path=None): + completed = subprocess.run( + [sys.executable, '-P', '-c', _COLD_OPEN, str(path or self.path)], + env={**os.environ, 'PYTHONPATH': str(ROOT)}, + text=True, capture_output=True, timeout=60, + ) + self.assertEqual(completed.returncode, 0, completed.stderr) + return completed.stdout.strip() def module(self): module = SnapshotModule.open(self.path, now=lambda: self.now, quarantine_seconds=10) @@ -311,22 +371,110 @@ def test_probe_sql_error_retains_typed_failure_without_transaction(self): self.assertNotIn('BEGIN IMMEDIATE', statements) self.assertFalse(module._store._connection.in_transaction) - def test_new_and_current_admission_have_one_full_integrity_audit(self): - created = _ObservedAdmissionStore(self.path) - try: - self.assertEqual(created.admission_events, [('configure', 0, False), ('integrity', 2, False)]) - finally: - created.close() + def test_new_and_current_admission_have_one_full_integrity_audit_per_process(self): + # The creating process audits its new file, and does not audit it again. + self.assertEqual(self.events(), [('configure', 0, False), ('integrity', 2, False)]) + for _ in range(2): + self.assertEqual(self.events(), [('configure', 2, False)]) + # A new process audits the existing file once, before configuration. + _begin_as_new_process() + self.assertEqual(self.events(), [('integrity', 2, False), ('configure', 2, False)]) for _ in range(2): - opened = _ObservedAdmissionStore(self.path) - try: - self.assertEqual(opened.admission_events, [('integrity', 2, False), ('configure', 2, False)]) - finally: - opened.close() + self.assertEqual(self.events(), [('configure', 2, False)]) + + def test_two_module_opens_in_one_process_audit_the_file_once(self): + with SnapshotModule.open(self.path, now=lambda: self.now) as initial: + snapshot = initial.create_snapshot(capture()).snapshot + _begin_as_new_process() + opens = [] + connect = sqlite3.connect + + def traced_connect(database, *arguments, **options): + # Observe each store connection from before its first statement. + connection = connect(database, *arguments, **options) + if Path(database).resolve() == self.path.resolve(): + opens.append([]) + connection.set_trace_callback(opens[-1].append) + return connection + + with mock.patch.object(store_module.sqlite3, 'connect', traced_connect): + for _ in range(2): + with SnapshotModule.open(self.path, now=lambda: self.now) as reopened: + self.assertEqual(reopened.load_content(snapshot), capture()) + first, second = opens + audit = ['PRAGMA integrity_check', 'PRAGMA foreign_key_check'] + self.assertEqual([statement for statement in first if statement in audit], audit) + # The later open omits exactly that pair and repeats every other statement. + self.assertEqual([statement for statement in first if statement not in audit], second) + self.assertIn('PRAGMA application_id', second) + self.assertIn('PRAGMA user_version', second) + self.assertTrue(any('FROM sqlite_schema' in statement for statement in second), second) + + def test_replaced_file_is_audited_again(self): + self.assertEqual(self.events(), [('configure', 0, False), ('integrity', 2, False)]) + self.assertEqual(self.events(), [('configure', 2, False)]) + audited = _file_identity(self.path) + # The replacement exists beside the audited file, so it has another inode. + replacement = self.path.with_name('replacement.sqlite3') + shutil.copyfile(self.path, replacement) + self.assertNotEqual(_file_identity(replacement), audited) + os.replace(replacement, self.path) + self.assertEqual(self.events(), [('integrity', 2, False), ('configure', 2, False)]) + self.assertEqual(self.events(), [('configure', 2, False)]) + + def test_corrupt_replacement_of_an_audited_file_is_rejected(self): + SQLiteSnapshotStore(self.path).close() + SQLiteSnapshotStore(self.path).close() + replacement = self.path.with_name('replacement.sqlite3') + shutil.copyfile(self.path, replacement) + _violate_foreign_key(replacement) + os.replace(replacement, self.path) + self.assert_code('SNAPSHOT_STORE.FOREIGN_KEY_FAILURE', lambda: SQLiteSnapshotStore(self.path)) + # A rejected file gains no audit record: the next open audits it again. + self.assert_code('SNAPSHOT_STORE.FOREIGN_KEY_FAILURE', lambda: SQLiteSnapshotStore(self.path)) + self.assertTrue(self.path.is_file()) + + def test_later_opens_keep_application_version_and_schema_checks(self): + for change, code in ( + ('PRAGMA application_id=1', 'SNAPSHOT_STORE.INVALID_APPLICATION'), + ('PRAGMA user_version=3', 'SNAPSHOT_STORE.UNSUPPORTED_VERSION'), + ('PRAGMA user_version=0', 'SNAPSHOT_STORE.INVALID_VERSION'), + ('CREATE TABLE unexpected (value TEXT)', 'SNAPSHOT_STORE.INVALID_SCHEMA'), + ('DROP TRIGGER child_index_no_update', 'SNAPSHOT_STORE.INVALID_SCHEMA'), + ): + with self.subTest(change=change), tempfile.TemporaryDirectory() as temporary: + path = Path(temporary) / 'snapshots.sqlite3' + SQLiteSnapshotStore(path).close() + self.assertEqual(self.events(path), [('configure', 2, False)]) + with closing(sqlite3.connect(path, isolation_level=None)) as changer: + changer.execute(change) + # Same file, already audited by this process: only the audit is omitted. + self.assert_code(code, lambda: _ObservedAdmissionStore(path)) + self.assertTrue(path.is_file()) + + def test_new_process_rejects_corruption_in_a_file_audited_elsewhere(self): + for corruption, code in (('foreign-key', 'SNAPSHOT_STORE.FOREIGN_KEY_FAILURE'), + ('check', 'SNAPSHOT_STORE.INTEGRITY_FAILURE')): + with self.subTest(corruption=corruption), tempfile.TemporaryDirectory() as temporary: + path = Path(temporary) / 'snapshots.sqlite3' + # This process audits the file; that record stays in this process. + SQLiteSnapshotStore(path).close() + self.assertEqual(self.cold_open(path), 'admitted') + with closing(sqlite3.connect(path, isolation_level=None)) as corruptor: + if corruption == 'foreign-key': + corruptor.execute("INSERT INTO content_files VALUES ('missing', 'a', X'', 0, 'digest')") + else: + corruptor.execute('PRAGMA ignore_check_constraints=ON') + corruptor.execute("INSERT INTO content_sets VALUES ('bad', 0)") + self.assertEqual(self.cold_open(path), code) + self.assertTrue(path.is_file()) def test_version_one_keeps_preconfiguration_guarded_and_final_audits(self): _, record = _populated_version_one_store(self.path) before = _version_one_rows(self.path) + # Building the fixture audited this same file as a current store. That + # record must not shorten any audit of its version-one admission. + self.assertTrue(store_module._audit_recorded(_file_identity(self.path))) opened = _ObservedAdmissionStore(self.path) try: self.assertEqual(opened.admission_events, [ @@ -338,6 +486,18 @@ def test_version_one_keeps_preconfiguration_guarded_and_final_audits(self): opened.close() self.assertEqual(_version_one_rows(self.path), before) + def test_version_one_migration_in_a_new_process_keeps_every_audit(self): + _populated_version_one_store(self.path) + before = _version_one_rows(self.path) + _begin_as_new_process() + self.assertEqual(self.events(), [ + ('integrity', 1, False), ('configure', 1, False), + ('integrity', 1, True), ('integrity', 2, True), ('integrity', 2, False), + ]) + self.assertEqual(_version_one_rows(self.path), before) + # The final destination audit is this process's audit of the migrated file. + self.assertEqual(self.events(), [('configure', 2, False)]) + def test_other_opener_migration_keeps_destination_audit(self): _populated_version_one_store(self.path) before = _version_one_rows(self.path) @@ -404,6 +564,8 @@ def test_current_corruption_is_rejected_before_persistent_configuration(self): else: corruptor.execute('PRAGMA ignore_check_constraints=ON') corruptor.execute("INSERT INTO content_sets VALUES ('bad', 0)") + # The first open by a process is the one that audits. + _begin_as_new_process() self.assert_code(code, lambda: _ObservedAdmissionStore(path)) self.assertTrue(path.is_file()) with closing(sqlite3.connect(path)) as observed: From da3c1287e859b02dbf7aec549b7d26c63d6d6b8d Mon Sep 17 00:00:00 2001 From: MrScripty Date: Thu, 12 Nov 2026 07:21:50 -0700 Subject: [PATCH 3/4] feat(engine): record MCP observations by default and never drop them The recorder exists to show how agents use the tool interface so the interface can be improved. As built it could not do that: it was off unless two flags were passed, so the application purpose was never recorded; it gave up for the life of the process after a 20 ms lock wait, so servers started together recorded nothing; and it stored argument shapes rather than values, so it could not say which standard was read, which facts were sent or which rejection came back. Always on. Every server process records to ${XDG_DATA_HOME:-~/.local/share}/standards-engine/observations/ interactions-v2.sqlite3 with no flags. --no-observe or STANDARDS_ENGINE_OBSERVE=off turns it off. In-process MCPServer construction records only when given a configuration, and every test and harness launch passes --no-observe; a guard test fails if a new launch site forgets. Invisible. Tool results are unchanged, a healthy recorder writes nothing to stderr, and a recording failure never changes or fails a call. No dropped records. A busy database queues the row in a bounded in-memory backlog and delivers it at the next call or at close. The database uses write-ahead mode. Eight processes started at the same instant on a new database now keep all 176 starts and terminals; the previous code kept 42. Loss that does occur (backlog overflow) is counted in the database. Seven-day window. Unchanged. A full file now evicts its oldest records instead of refusing new ones. Schema v2 uses a new file; a v1 file is refused and left untouched. Useful values. Navigation calls keep targets, options and route facts as sent, bounded to 200 characters per string. Authoring calls keep only identifiers and enum words, never bodies, titles, rationales or evidence. Results keep kind, status, code and the selected or returned module IDs. A client thread id is stored only as a keyed hash, with a main or subagent marker. No other request metadata is read. The report gains a readable text summary (rejection rates, latency and size percentiles, refused fact names and values, most-read targets, repeat reads per thread) and a --since-days filter. MCP-OBSERVABILITY.md is rewritten for the new contract. Co-Authored-By: Claude Fable 5.2 --- .../generated/suite-inputs.json | 8 +- tools/standards_engine/MCP-OBSERVABILITY.md | 460 +++++---- tools/standards_engine/README.md | 22 +- .../standards_engine/interaction_observer.py | 904 ++++++++++++++---- .../standards_engine/standards_engine/mcp.py | 16 +- .../tests/agent_efficiency_trace.py | 2 +- .../tests/codex_discovery_client.py | 2 +- .../tests/codex_navigation_client.py | 4 + .../tests/mcp_policy_registration_client.py | 2 +- .../tests/mcp_workflow_client.py | 2 +- .../tests/test_agent_interaction_transport.py | 2 +- .../tests/test_consumer_publication.py | 2 +- .../tests/test_coverage_publication.py | 1 + .../tests/test_discovered_workflow.py | 2 +- .../tests/test_immutable_work_reuse.py | 2 +- .../tests/test_input_discovery.py | 2 +- .../tests/test_interaction_observer.py | 799 +++++++++++++--- tools/standards_engine/tests/test_mcp.py | 1 + .../tests/test_navigation_indexes.py | 1 + .../tests/test_numeric_boundary.py | 2 +- .../tests/test_output_delivery.py | 2 +- .../tests/test_process_reuse.py | 2 +- .../tests/test_proposal_reuse.py | 2 +- .../tests/test_purpose_transport.py | 2 +- .../standards_engine/tests/test_read_many.py | 2 +- .../tests/test_routing_fact_transport.py | 2 +- .../tests/test_runtime_identity.py | 2 +- .../tests/test_schema_presentation.py | 2 +- .../tests/test_storage_lifecycle_transport.py | 2 +- .../tests/test_typed_routing_workflow.py | 2 +- .../tests/test_workflow_presentation.py | 2 +- .../tests/workflow_interaction_trace.py | 2 +- 32 files changed, 1736 insertions(+), 524 deletions(-) diff --git a/evaluation/standards-effectiveness/generated/suite-inputs.json b/evaluation/standards-effectiveness/generated/suite-inputs.json index 9dbde56a..4c5c9332 100644 --- a/evaluation/standards-effectiveness/generated/suite-inputs.json +++ b/evaluation/standards-effectiveness/generated/suite-inputs.json @@ -7347,7 +7347,7 @@ ] }, { - "digest": "sha256:c85b4e2d525e7d644261658b19e35b815e86f6386754d327f56de5bc8be52caa", + "digest": "sha256:142cffd188781617e4641812e2f9bd33b99edf7bbbbd1d54e613bbcbcc8864a2", "path": "tools/standards_engine/README.md", "state": "present", "uses": [ @@ -7661,7 +7661,7 @@ ] }, { - "digest": "sha256:bc14652d3aa78ea400495d7f89fe9c4662c4de16acf759cac41d8279239a2a78", + "digest": "sha256:1a6d59145f4b8d43c67c23787fc450b60b569bbd65089fca9e6817b17848edae", "path": "tools/standards_engine/standards_engine/interaction_observer.py", "state": "present", "uses": [ @@ -7685,7 +7685,7 @@ ] }, { - "digest": "sha256:899c6bb6605a9b6e07bee7992c48120f3dd10fe2a8bf77fa9d20a35a3575ab22", + "digest": "sha256:49b9ba34111d7fff7dfb575ec3e7e29d8d2be259ab35ba03bd7af26feb5b8c89", "path": "tools/standards_engine/standards_engine/mcp.py", "state": "present", "uses": [ @@ -7887,7 +7887,7 @@ ] }, { - "digest": "sha256:2a5e6761f159c63e3c79f8fed0d90e1edcf987ea78a86fc9878a2866c840ef03", + "digest": "sha256:bcb26ee92ec9e34ca2e04280c9122f43a81a515dd195b73d53dc864d55649e06", "path": "tools/standards_engine/tests/test_coverage_publication.py", "state": "present", "uses": [ diff --git a/tools/standards_engine/MCP-OBSERVABILITY.md b/tools/standards_engine/MCP-OBSERVABILITY.md index 44acb8e4..d344509b 100644 --- a/tools/standards_engine/MCP-OBSERVABILITY.md +++ b/tools/standards_engine/MCP-OBSERVABILITY.md @@ -1,193 +1,293 @@ -# Operator MCP interaction observations +# MCP interaction recording -This optional local recorder observes the existing MCP boundary. It does not add -agent tools, modify domain outcomes or workflow authority, make model calls, retry -operations, or change the installed agent catalog. The qualification observer remains -**observer v3**, with its existing raw-event acquisition, assessment and exact-source -replay. The production recorder does not import the harness or rewrite verdicts. +Every Standards Engine MCP server process records how its tools are used, so the +interface can be improved from what agents actually send and receive. Recording is +always on, keeps about seven days, and is invisible to the agent. -The sanitized recorder selected by `--observe-database` and -`--observe-deployment` is the sole supported recording mode. The earlier raw -recorder and its `--observation-db` option are retired. Historical raw databases -retain their original schema and remain separate evidence; configure a new -dedicated database for sanitized observations. +- **Always on.** No flag is needed, in either purpose, for any client. +- **Invisible.** Recording adds no tool, catalog entry or instruction text and + changes no result. It never raises into a request. A recording problem is + reported only on the server's stderr. +- **No dropped records.** A call that cannot be written at once waits in memory + and is written by a later call or when the process closes. +- **Seven days.** Older calls are removed automatically. -## Configuration and authority +This is the only MCP recorder. The qualification observer remains **observer v3** +with its own raw-event evidence and exact-source replay; the recorder neither +imports that harness nor rewrites its verdicts. -Recording is off unless the operator explicitly supplies **both** options below. -The commands illustrate a new operator-owned installation, not instructions to -enable an existing one without its operator's approval. Replace paths and the -nonsensitive deployment label with operator-selected values: +## Where the file is + +```text +${XDG_DATA_HOME:-~/.local/share}/standards-engine/observations/interactions-v2.sqlite3 +``` + +The server creates that directory with mode 0700 if it is missing and the file with +mode 0600. Existing directories and permissions are never changed. + +| Launch option | Default | Meaning | +| --- | --- | --- | +| `--observe-database PATH` | the file above | Record somewhere else. The directory must already exist; it is not created. | +| `--observe-deployment LABEL` | `local` | A nonsensitive label stored with each server process. | +| `--observe-max-calls N` | 10000 | 16–100000 calls kept, across all processes. | +| `--observe-max-age-seconds N` | 604800 (7 days) | 60–31536000 seconds since a call began. | +| `--observe-max-bytes N` | 33554432 (32 MiB) | 1048576–1073741824 bytes of database file. | +| `--no-observe` | recording on | Do not record this process. | + +## Turning it off + +Either of these stops recording for a server process. Nothing is created or opened. ```sh -python3 -m tools.standards_engine.standards_engine.mcp \ - --repo-root /operator/standards --purpose authoring \ - --observe-database /operator/private-diagnostics/interactions.sqlite \ - --observe-deployment qualification-fixture +python3 -m tools.standards_engine.standards_engine.mcp --purpose application --no-observe +STANDARDS_ENGINE_OBSERVE=off python3 -m tools.standards_engine.standards_engine.mcp --purpose application ``` -The database directory must already exist, be operator controlled and exclude -concurrent untrusted replacement of the directory or its ancestors. This initial -recorder supports POSIX regular local files and SQLite rollback journals only. -It refuses final-component symlinks, hardlinked files, existing group/world-readable -files, unsupported journal modes and unsupported or unrelated database schemas. -New files use mode 0600. It does not chmod existing files, create directories or -use an Engine domain database. Do not place it in a repository, tracked directory, -network share or an agent-visible artifact directory. The operator must select -appropriate disk access, encrypted storage/backup and disposal arrangements. - -**Same-user filesystem access is not a security boundary.** A process with the -same OS authority can read, modify or remove the recorder database and stderr. -Tool-catalog invisibility does not create confidentiality or tamper evidence. -The recorder therefore excludes payload values regardless of filesystem modes. -The deployment label must not contain account identities, credentials or secrets. -No network exporter is included. Export/sharing requires separate operator review. - -Policy defaults and valid ranges: - -| Option | Default | Range / meaning | +The environment variable wins over every `--observe-*` option. Tests and harnesses +that start a server pass `--no-observe`, set the variable, or name a temporary +`--observe-database`, so they never write to a developer's own file; a test +enforces this. Constructing +`MCPServer` directly in Python records only when it is given a `RecorderConfig`. + +## What is recorded + +One row per server process (`sessions`), one per request (`interactions`) and one +per response (`events`). Notifications are not recorded. + +**Per server process** + +- A random process id, start time, purpose, interface version and the catalog, + schema and implementation digests the process actually loaded. +- The deployment label, and the client name and version from `initialize` + `clientInfo` (for example `codex-mcp-client 0.163.0`). +- Per-tool input and output schema digests, stored once per distinct catalog. +- How many calls this process pruned, and how many rows it lost (see below). + +**Per request** + +- Time, order within the process, method, installed operation name, and whether the + response was written to stdio or only constructed. +- `input_shape`: the argument structure with every value replaced by its type. +- `arguments`: the values listed in the next section, and nothing else. +- `request_bytes` (the whole JSON-RPC line, client metadata included) and + `arguments_bytes` (the `arguments` object alone). +- `expected_catalog` as `matches`, `differs` or `unspecified`; the operation a + `describe_input`/`describe_output` call asked about. +- `thread`: a 16-hex-digit keyed hash of the client's thread or session id, when + the request metadata carries one, and `origin`: `main`, `subagent` or `unknown`. + Codex supplies both. A client that sends neither is recorded with no thread and + `unknown`; reports then treat the server process as the thread. + +**Per response** + +- Time, duration, `response_bytes` (the whole line) and `result_bytes` (one + serialization of `structuredContent`; the line carries that payload twice). +- An outcome word: the result's own `outcome` or `status` (`complete`, + `needs-facts`, `needs-action`, `requires-change`, `ready`, `draft`, `applied`, + `stale`, `rejected`, `recovery-required`, `invalid`, `unavailable`, `unsupported`, + `unauthorized`), or `input-invalid`, `tool-exception`, a protocol error class, + `response`, or `unknown` for an interrupted call. +- Where input validation failed: schema field names and the constraint keyword. +- `result`: `kind`, `status`, `code` and `outcome`; for a route, the selected + target IDs, the IDs of facts still unresolved, and the content page's offset, + total, item count and item IDs; for reads, the target IDs returned. + +### Argument values that are kept + +Values are kept only for names on an explicit list per operation. Any other +argument appears only as a type in `input_shape`. Strings are cut at 200 +characters, and lists and fact maps at 32 entries, with a `[truncated]` marker. A +whole `arguments` object over 8 KB keeps only its top-level scalars and +`truncated`. + +| Operation | Kept as sent | +| --- | --- | +| `read` | `target`, `detail`, `include_coverage`, `include_routing` | +| `read_many` | the same four names for each item | +| `route` | `detail`; `content.limit` and `content.offset`; every fact name and value | +| `related` | `target`, `direction`, `transitive`, `groups` | +| `relationship_groups` | `limit`, `offset` | +| `describe_input`, `describe_output` | `operation`, `selector`, `limit`, `offset` | +| `inspect` | the handle's `kind` and `child_kind` | +| `query`, `query_proposal`, `preview_application` | the nested request's `kind`, the `read`/`related` names above, and route facts; the revision handle's `kind` | +| `routing_facts`, `runtime_info` | nothing beyond the snapshot note below | + +A supplied `snapshot` is recorded as a 12-hex-digit hash of its id, so reuse of +one snapshot is visible without keeping the handle. + +**Route facts are kept exactly as the agent sent them**, including names and +values the routing vocabulary does not contain. An agent that invents a fact such +as `python`, or passes a sentence as a `task` fact, is the most useful signal this +recording has, so up to 200 characters of that text are stored. + +Every other operation is an authoring operation (`propose`, `revise`, +`resolve_workflow`, `resolve_many`, `review`, `apply`, `recover`, `analyze`, +`workflow_status`, `workflow_details`, `resume`, `maintain_evidence` and the +advanced native operations). For these, a value is kept only when all of the +following hold: + +- its name is declared by the installed input schema at that position; +- it is not inside `body`, `content`, `text`, `prompt`, `message`, `rationale`, + `reason`, `evidence`, `explicit_exclusions`, `details`, `metadata` or a + credential-like field; +- its name is one of: `kind`, `child_kind`, `detail`, `action`, `section`, + `result`, `decision`, `owner`, `disposition`, `relation`, `artifact_kind`, + `authority`, `level`, `role`, `origin`, `lifecycle`, `direction`, `id`, `policy`, + `standard`, `consumer`, `target`, `source_policy`, `subject`, `evidence_owner`, + `after_policy`, `rule`, `fact`, `requires`, `specializes`, `successors`, + `predecessors`, `groups`, `limit`, `offset`, `apply`, `transitive`; +- it is a boolean, a small number, or a string shaped like a canonical identifier + (letters, digits and `._:/-`, no spaces) that contains no digest, UUID or other + long hexadecimal run. + +So an edit is recorded as, for example, +`{"kind":"revise-policy-unit","policy":"workflow.planning.written-plan-applicability"}` +and a handle as `{"kind":"analysis-handle"}`. + +### What is never recorded + +- Standards text, bodies, titles, summaries, rationales, intents, headings, + conditions, evidence text, file paths, or any other prose in an authoring call. +- Result content: no standard text, messages, details or summaries. +- Handle ids, digests, request ids and progress tokens. +- Raw thread, session or turn ids, model names, workspace paths, repository URLs, + or anything else in request `_meta`. +- Argument names the installed schema does not declare (they are counted), other + than route fact names. +- Tool names the server does not install, exception messages and tracebacks. +- Credentials or tokens, under any name. + +## The seven-day window + +Each new call first removes calls that began more than seven days ago, then the +oldest calls beyond the count limit. When the file is within one sixteenth of its +byte limit the oldest sixteenth of calls is removed as well, so a full file never +stops new recording. A call and its response are removed together, and a server +process row goes when its last call does (one that carries a loss count stays +until it is seven days old). + +Removal happens only while something is recording: an idle file keeps its last +contents until the next call. Deleted rows are overwritten in the file +(`secure_delete`), but backups, filesystem snapshots and storage remnants are +outside the recorder's reach. The file does not shrink; freed space is reused. + +## No dropped records, and what can still be lost + +Each request is written before it is dispatched and each response after it has +been delivered. If the database is busy or unavailable, the row stays in an +in-memory backlog of at most 1,000 rows and the call proceeds: + +- A busy database is waited for at most 20 ms per attempt, and 250 ms once at + process start. The backlog is written by the next request or response, and at + orderly close with a wait of up to 5 seconds. +- Recording is never switched off. After any other storage error the connection + is reopened on a later call. +- Several processes creating the file at the same instant all succeed: the first + publishes the whole schema in one commit and the others find it complete. + +What cannot be recovered, and how it shows: + +| Situation | Effect | Visible as | | --- | --- | --- | -| `--observe-max-calls` | 10000 | 16–100000 retained interaction starts, across all processes | -| `--observe-max-age-seconds` | 604800 | 60–31536000 seconds since begin | -| `--observe-max-bytes` | 33554432 | 1048576–1073741824 bytes, SQLite main-file page quota | - -All processes sharing a database must use the same privacy/retention policy. -Each connection enforces its configured page quota; mixed policies do not establish -a shared minimum. Rollback journals may temporarily add up to roughly another -main database's size, plus SQLite bookkeeping and bounded report/sort working space. -The directory's filesystem quota remains the final bound on all files. No WAL, -background thread, queue or telemetry write retry is introduced. Main files do not -shrink on deletion: SQLite reuses freed pages. No automatic VACUUM/rebuild occurs. - -## Persisted contract and lifecycle - -Schema v1 has three owners within one recorder database: - -- `sessions`: exact startup runtime metadata (process instance UUID, interface, - purpose, catalog/schema/implementation digests), deployment label and per-tool - input/output schema digests. These bind the actually loaded source and effective - eager/on-demand catalog. They do not prove a client refreshed its catalog. -- `interactions`: immutable begin evidence, recorder UUID, session-local ordinal, - wall-clock begin instant, method/installed operation, sanitized input shape and - its shape-only digest, safe discovery target, expected-catalog match state, - request byte measurement and delivery scope. This row is the begin event. -- `events`: at most one independent end/error/incomplete observation per begin, - with monotonic elapsed milliseconds, wall-clock finish instant, response bytes, - fixed outcome class and sanitized validation locations/constraint keywords. - -Each mutation owns `BEGIN IMMEDIATE`/commit/rollback. Schema admission is checked -under the same lock, including exact owned DDL and application ID. Zero-length new version-0 -SQLite files migrate transactionally once to v1; v1 reopens without rewriting -observations. Future versions, unrelated/partial schemas and corruption are -unavailable, never deleted or replaced. Migration interruption rolls back under -SQLite recovery. Backup a stopped database before any future supported migration; -no downgrade migration or automatic restoration is currently provided. - -Stdio begins are committed before dispatch. End/error evidence is committed only -after the ordinary response write and flush return. `stdio-flushed` does not prove -the client received/processed the response. The direct Python `dispatch` path uses -`constructed` scope, which proves only that a response was produced. Parsing errors -and malformed requests with responses are observed; valid notifications have no -request/response pair and are excluded. Client IDs and clientInfo are not retained. - -A caught tool exception has a fixed `tool-exception` category; domain outcome may -be unknown. Typed validation rejections retain `input-invalid` plus safe field -locations. Other protocol/domain classes use fixed vocabularies, never exception -messages, tracebacks or arbitrary result codes. Transport/interruption errors -append `incomplete/unknown` if storage remains available. A killed process or a -failed terminal write leaves an unmatched begin. Reports label it unknown; startup -does not complete old calls or presume other live recorders died. Telemetry cannot -prove a domain effect did or did not commit and cannot authorize a mutation retry. - -Age and count retention run transactionally on each new observed request. Expiry -is event-driven: an idle/stopped database retains expired records until recording -resumes or the operator disposes of it. Starts and their terminal evidence are -removed together; unreferenced session manifests are removed in the same -transaction. Retention can evict an in-flight call from another process. Its late -terminal is counted as dropped and recording continues; no start is recreated. -Retention can remove evidence before a later success, so history/repair denominators -are limited to retained observations. Per-session prune counters themselves expire -with their session; they are not installation-lifetime loss totals. Secure deletion -is enabled for recorder deletes; it does not erase backups, filesystem snapshots, -SQLite journal history or storage-device remnants. - -## Privacy projection - -No credentials/tokens, scalar input values, raw request IDs, complete prompts, -model transcripts, standards/repository bodies, domain handles or arbitrary tool -outputs are stored or hashed. Every scalar input becomes only its type. - -At each structural location, only property names declared by the installed input -schema can appear. Recursive references/unions supply possible property names; -this is a disclosure projection, not another input validator. Dynamic map keys -and unknown names are removed and counted. Sensitive subtrees (`body`, `content`, -`text`, `prompt`, `message`, `rationale`, `reason`, `evidence`, `details`, `metadata`, -credentials/password/token/secret/authorization/api_key/environment/env) are replaced -by a redacted marker. Other input fields still retain no scalar values. Shapes -have at most 64 visited nodes, depth 5, four sampled array items and 8192 serialized -ASCII bytes. Truncation is explicit. Validation feedback is limited to eight -issues, depth-five schema-owned pointer components, wildcard indices/dynamic keys -and fixed constraint keywords; messages and offending values are omitted. - -An input-shape digest groups structural samples, not raw values or exact semantic -variants. Two scalar variants can deliberately have the same shape. Discovery -operation values are retained only on exact installed-operation membership. -Expected catalogs become only unspecified/matches/differs. Selector values are -not retained. There is no legitimate cross-process session/task ID in the current -MCP server: reports do not infer continuation from prompts or domain handles. - -## Health and recovery - -Operator stderr receives fixed JSON health at recorder startup, first degradation, -retention-dropped terminal observations, and orderly close. It carries state, -fixed reason, starts/terminals recorded, observations dropped and interactions -pruned in that process. Stderr failure itself is guarded. Health is not advertised -in the agent catalog or appended to an Engine result. - -Unavailable, locked (20 ms busy budget), full, unsafe, unsupported or corrupt -storage disables recording for that process and reports degraded health. Existing -begin evidence remains independent; no completion is invented. No further writes -or retries occur. The MCP operation still returns its original outcome and runs -once, including a domain result committed before the telemetry failure. A failed -start means that interaction may have no retained evidence at all. Health counters -cover attempted observations, not an exact census of lost interactions. - -The operator must monitor stderr/process supervision independently of SQLite, -fix the owned storage condition and restart the MCP process to recover recording. -Preserve a corrupt/unrecognized database for diagnosis; select a separately -approved fresh path rather than silently rebuilding it. A report cannot recover -health messages that were unavailable/lost with stderr or process termination. - -## Read-only inspection +| Process killed during a call | The request has no response row. | "without an outcome" in the report | +| Backlog over 1,000 rows | The oldest waiting rows are dropped. | `lost` on the process row and in the report | +| A response whose request row was already pruned or dropped | The response is not stored. | counted in the same `lost` | +| Database unreachable until the process ends | Its rows are never written. | stderr only: nothing can be stored | +| Process killed while rows are waiting | The waiting rows are gone. | not visible | + +In ordinary use the write takes well under a millisecond, so the last two cases +need a database that stays locked or broken for the life of a process. + +## Storage + +The database uses SQLite write-ahead logging. That is what keeps recording out of +the way: a commit holds the write lock for microseconds instead of the several +milliseconds a synced rollback journal needs, and reading a report never blocks a +server. For the person reading the data it means: + +- While any server is running there are three files: the database, `-wal` and + `-shm`. Recent calls may exist only in `-wal`. Read through SQLite (the report + does) or copy all three; do not copy the database file alone. +- The file must be on a local filesystem. Network shares are not supported. +- After an operating-system crash or power loss the last few commits may be + missing. A killed or crashed server process loses nothing that was committed. +- `-wal` is usually a few megabytes on top of the byte limit and is removed when + the last server closes. + +The recorder accepts only a new empty file or its own schema v2. It refuses +symlinks, hardlinked files, files readable by group or others, unrelated SQLite +files, files larger than the byte limit, and other schema versions, and leaves +them untouched. That includes schema v1 files written by earlier releases: they +are historical evidence, are never migrated or deleted, and are no longer written +because the default file name is new. + +**Same-user file access is not a security boundary.** Any process running as the +same user can read or change the recording. The thread hash key is stored in the +same database: it keeps raw client ids out of the file and out of shared reports, +but it does not hide a thread from someone who holds both the file and the id. Do +not put the file in a repository or an agent-visible directory, and review a +report before sharing it: route facts can contain agent-written text. + +## Health messages + +A healthy recorder writes nothing. When recording changes state, one line goes to +the server's stderr: + +```text +standards-engine observer {"backlog":6,"lost":0,"pruned_interactions":0,"reason":"storage-locked","recorded_starts":2,"recorded_terminals":2,"state":"degraded"} +``` + +`degraded` means rows are waiting in memory for the stated reason; it does not mean +recording stopped. A line with `healthy` follows when they have been written, and a +final line is written at close if anything was reported or lost. Reasons are fixed +words: `storage-locked`, `storage-unavailable`, `storage-full`, `storage-corrupt`, +`storage-error`, `unsafe-database-file`, `unsupported-database-schema`, +`invalid-database-schema`, `nonpristine-database`, `database-over-budget`, +`unsupported-journal-mode`, `unsupported-filesystem` and `recorder-error`. Paths, +SQL and payloads never appear. + +## Reading the recording ```sh -python3 -m tools.standards_engine.standards_engine.interaction_observer \ - --database /operator/private-diagnostics/interactions.sqlite --limit 100 +python3 -m tools.standards_engine.standards_engine.interaction_observer +python3 -m tools.standards_engine.standards_engine.interaction_observer --since-days 2 +python3 -m tools.standards_engine.standards_engine.interaction_observer --format json --limit 100 ``` -This operator CLI opens an existing v1 database in SQLite read-only/query-only -mode and uses one read snapshot. It never creates, migrates, prunes or modifies -observations. JSON goes only to the operator's stdout; no output file is created. -Each group/session/histogram section is bounded by `--limit` (1–1000), with explicit -truncation flags. Sequence analysis scans at most the latest 10000 retained starts; -its scan count and truncation are reported. Aggregate queries scan the bounded -retained database (at most the configured 100000 starts). Sessions show the latest -bounded set in chronological order; catalog comparisons cover those shown manifests. - -The report provides operation usage, error distribution by structural input shape, -sanitized field/constraint failures, observed latency and serialized bytes with -measurement counts, sanitized shapes for successful and failed calls, session -identity and catalog additions/removals/schema changes. Totals include all retained -starts/terminals; operation/failure/shape rows identify their delivery scope and -have their own counts. An end is a non-error MCP response, not evidence the domain -workflow completed. Missing measurements are null and have separate denominators. - -Sequence histograms count preceding observed errors/discoveries before a non-error -tool response, by session, delivery scope and operation. Their denominator is the -reported number of non-error responses in the bounded scan. This is a diagnostic -candidate for investigating repair loops, not proof that errors caused discovery, -that a schema was acquired before use, or that separate tasks share agent intent. -No raw trace or redacted request can be reconstructed. Bytes are JSON/stdio bytes, -not model tokens or provider billing. Preserve independent qualification evidence -for observer-v3 replay and exact behavioral assessment; do not export actual logs -with code or automatically rewrite contracts from these summaries. +`--database PATH` reads another file. The command opens the database read-only, +uses one consistent snapshot and never creates, changes or prunes a recording. +SQLite may leave an empty `-wal` and a `-shm` file beside a database it has read. + +The default output is about one screen of text: + +- calls by client, purpose and interface version; +- per operation: calls, share rejected, p50/p90/max duration and p50/max result + size; +- the most frequent rejections with their code, the field that failed and the + value that was sent; +- route fact names and values the server refused and never accepted in the window; +- the most-read targets, counting `read`, `read_many` and route content pages; +- how often a thread read a target it had already read; +- routes sent without a snapshot; +- threads, tool calls and repeated reads for main agents, subagents and clients + that identify neither; +- calls without an outcome, rows lost and calls pruned. + +`--format json` gives every section in full, plus the structural input shapes, +the latest server processes, catalog differences between them and the +error-then-success sequences. `--limit` (1–1000) bounds the rows per section and +truncation is flagged. + +How to read it: + +- "Refused and never accepted" is inferred from the recording, not checked against + a vocabulary: a fact name counts when its route was rejected for a fact and the + server neither accepted that name nor listed it as an unresolved fact in the + window. A value counts when the rejection points at its fact and that value was + never accepted. +- A thread is the hashed client thread, or the server process when the client sent + none. Repeat reads are counted within a thread. +- An unmatched call has an unknown outcome. The recording cannot show whether a + mutation committed and must not be used to decide a retry. +- Bytes are serialized JSON, not model tokens or billing. +- Recorded requests cannot be replayed. Keep qualification evidence for that. diff --git a/tools/standards_engine/README.md b/tools/standards_engine/README.md index 85f52a8d..8b42403c 100644 --- a/tools/standards_engine/README.md +++ b/tools/standards_engine/README.md @@ -38,10 +38,13 @@ normative text, policy subjects, consumer relationships and other certificates remain intact. It supplies no replacement coverage claim. Restart/reconnect after installing the coordinated source and generated contracts; preserve stores. -Optional sanitized operator measurements use `--observe-database` with -`--observe-deployment`; see [MCP observability](MCP-OBSERVABILITY.md). Recording is -disabled by default and preserves the existing qualification observer v3 and -agent-visible interface. This is the sole supported MCP recorder. +Every MCP server process records how its tools are used in an operator-only local +SQLite file and keeps about seven days. See +[MCP interaction recording](MCP-OBSERVABILITY.md) for exactly what is and is not +recorded, where the file is, and how to turn it off (`--no-observe` or +`STANDARDS_ENGINE_OBSERVE=off`). Recording changes nothing an agent can see and +preserves the existing qualification observer v3. This is the sole supported MCP +recorder. ## Purpose separation (interface 31) @@ -424,8 +427,15 @@ after installation without changing launch arguments or deleting stores. The earlier raw invocation recorder was retired on 2026-10-22. Its `--observation-db` launch option is no longer accepted. Historical raw databases remain operator-owned evidence and are not converted, reused or deleted. -Select a new dedicated database with `--observe-database` and a nonsensitive -`--observe-deployment` label. Follow the [sanitized recorder's operating contract](MCP-OBSERVABILITY.md) + +The opt-in sanitized recorder that replaced it (schema v1, selected with +`--observe-database` and `--observe-deployment`) is in turn replaced by always-on +recording in a new default file (schema v2). Its v1 databases are also left +untouched. A registration that still names a v1 file with `--observe-database` +is refused that file and records nothing until the option is removed; remove both +options to use the default location. `--observe-database` now only overrides the +location and `--observe-deployment` defaults to `local`. Follow the +[recording contract](MCP-OBSERVABILITY.md) for permissions, retained data, retention and reports. The [original observation plan](../../docs/plans/agent-interaction-observation/plan.md) retains its historical acceptance and qualification records. diff --git a/tools/standards_engine/standards_engine/interaction_observer.py b/tools/standards_engine/standards_engine/interaction_observer.py index 197b060a..12e997f4 100644 --- a/tools/standards_engine/standards_engine/interaction_observer.py +++ b/tools/standards_engine/standards_engine/interaction_observer.py @@ -1,40 +1,61 @@ -"""Opt-in operator observations. Never an Engine store or an agent tool. +"""Always-on operator observations. Never an Engine store or an agent tool. The recorder owns sanitization, SQLite transactions, retention and fail-open -health. No caller-supplied scalar is persisted. A missing terminal event means -unknown outcome; restarting a recorder never manufactures a completion. +health. Caller values are persisted only through the explicit allow-lists below. +A row that cannot be written waits in a bounded in-memory backlog. A missing +terminal event means unknown outcome; a recorder never manufactures a completion. """ from __future__ import annotations import argparse -from collections import Counter +from collections import Counter, deque from dataclasses import dataclass +from datetime import datetime, timezone import hashlib +import hmac +from itertools import islice import json +import math import os from pathlib import Path import re +import secrets import sqlite3 import stat import sys import time -from typing import TextIO +from typing import Iterable, TextIO import uuid -SCHEMA_VERSION = 1 +SCHEMA_VERSION = 2 APPLICATION_ID = 0x53454F42 # SEOB, separate from every Engine domain database. +DEFAULT_DATABASE_NAME = 'interactions-v2.sqlite3' +DEFAULT_DEPLOYMENT = 'local' DEFAULT_MAX_CALLS = 10_000 DEFAULT_MAX_AGE_SECONDS = 7 * 24 * 60 * 60 DEFAULT_MAX_BYTES = 32 * 1024 * 1024 -BUSY_TIMEOUT_MS = 20 +BUSY_TIMEOUT_MS = 20 # Lock wait per begin/finish; the backlog delivers later. +OPEN_TIMEOUT_MS = 250 # Lock wait at process start, before any request is served. +CLOSE_TIMEOUT_MS = 5_000 # Lock wait for the last delivery at orderly close. +LOCK_POLL_SECONDS = 0.0005 +MAX_BACKLOG = 1_000 MAX_SHAPE_NODES = 64 MAX_SHAPE_DEPTH = 5 MAX_SHAPE_BYTES = 8 * 1024 MAX_ARRAY_ITEMS = 4 +MAX_VALUE_CHARS = 200 +MAX_VALUE_ITEMS = 32 +MAX_VALUE_DEPTH = 3 +MAX_VALUE_NODES = 512 +MAX_ARGUMENT_BYTES = 8 * 1024 +MAX_RESULT_IDS = 128 MAX_FEEDBACK_ISSUES = 8 MAX_FEEDBACK_POINTER_CHARS = 512 +MAX_THREAD_CHARS = 256 MAX_REPORT_ROWS = 1000 MAX_SEQUENCE_SCAN = 10_000 +TEXT_ROWS = 10 +TRUNCATED = '[truncated]' METHODS = frozenset({'initialize', 'tools/list', 'tools/call', 'ping'}) SENSITIVE_FIELDS = frozenset({ 'body', 'content', 'text', 'prompt', 'message', 'rationale', 'reason', @@ -45,20 +66,63 @@ 'type', 'required', 'additionalProperties', 'enum', 'const', 'oneOf', 'anyOf', 'allOf', 'not', 'minimum', 'maximum', 'minItems', 'maxItems', 'minLength', 'maxLength', 'pattern', 'format', 'uniqueItems', + 'fact', 'evidence_ref', # The Engine's own fixed keywords. }) -OUTCOMES = frozenset({'invalid', 'unsupported', 'unavailable', 'stale', - 'rejected', 'recovery-required', 'needs-action', - 'requires-change', 'complete', 'ready'}) +OUTCOMES = frozenset({'invalid', 'unsupported', 'unavailable', 'unauthorized', 'stale', + 'rejected', 'recovery-required', 'needs-action', 'needs-facts', + 'requires-change', 'complete', 'ready', 'draft', 'applied'}) + +# Values that may be persisted, by operation. A name absent from these lists is +# never stored as a value; it remains a type in input_shape. +_PAGE = ('limit', 'offset') +_READ = ('target', 'detail', 'include_coverage', 'include_routing') +_RELATED = ('target', 'direction', 'transitive', 'groups') +_DESCRIBE = ('operation', 'selector', *_PAGE) +# Navigation: values exactly as sent. Structured members (snapshot, read_many +# items, route content and facts, handles, nested requests) are projected by +# navigation_values() for the operations named here. +NAVIGATION = { + 'read': _READ, 'read_many': (), 'route': ('detail',), 'routing_facts': (), + 'related': _RELATED, 'relationship_groups': _PAGE, 'inspect': (), + 'describe_input': _DESCRIBE, 'describe_output': _DESCRIBE, 'runtime_info': (), + 'query': (), 'query_proposal': (), 'preview_application': (), +} +HANDLES = {'inspect': 'handle', 'query_proposal': 'revision', 'preview_application': 'revision'} +REQUESTS = {'route': ('kind',), 'read': ('kind', *_READ), 'related': ('kind', *_RELATED)} +# Every other operation is authoring: only these names, and only values shaped +# like a canonical identifier, an enum word, a boolean or a small integer. +IDENTIFIER_FIELDS = frozenset({ + 'kind', 'child_kind', 'detail', 'action', 'section', 'result', 'decision', 'owner', + 'disposition', 'relation', 'artifact_kind', 'authority', 'level', 'role', 'origin', + 'lifecycle', 'direction', + 'id', 'policy', 'standard', 'consumer', 'target', 'source_policy', 'subject', + 'evidence_owner', 'after_policy', 'rule', 'fact', 'requires', 'specializes', + 'successors', 'predecessors', 'groups', + 'limit', 'offset', 'apply', 'transitive', +}) +IDENTIFIER = re.compile(r'[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}') +OPAQUE = re.compile(r'[0-9a-fA-F]{16}|[0-9a-f]{8}-[0-9a-f]{4}-') # Digests, handle ids, UUIDs. +RESULT_KIND = re.compile(r'[a-z][a-z0-9-]{0,63}') +RESULT_CODE = re.compile(r'[A-Z][A-Z0-9_]{0,31}(\.[A-Z][A-Z0-9_]{0,47}){1,3}') SCHEMA_DDL = ( - 'CREATE TABLE sessions (id TEXT PRIMARY KEY, started REAL NOT NULL, runtime TEXT NOT NULL, deployment TEXT NOT NULL, catalog TEXT NOT NULL, pruned INTEGER NOT NULL DEFAULT 0)', - 'CREATE TABLE interactions (id TEXT PRIMARY KEY, session TEXT NOT NULL REFERENCES sessions(id), ordinal INTEGER NOT NULL, started REAL NOT NULL, method TEXT NOT NULL, operation TEXT NOT NULL, input_shape TEXT NOT NULL, shape_digest TEXT NOT NULL, discovery_operation TEXT, catalog_state TEXT NOT NULL, request_bytes INTEGER, scope TEXT NOT NULL, UNIQUE(session, ordinal))', - "CREATE TABLE events (interaction TEXT PRIMARY KEY REFERENCES interactions(id) ON DELETE CASCADE, phase TEXT NOT NULL CHECK(phase IN ('end','error','incomplete')), finished REAL NOT NULL, duration_ms REAL NOT NULL, response_bytes INTEGER, outcome TEXT NOT NULL, feedback TEXT NOT NULL)", + 'CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)', + 'CREATE TABLE catalogs (digest TEXT PRIMARY KEY, tools TEXT NOT NULL)', + 'CREATE TABLE sessions (id TEXT PRIMARY KEY, started REAL NOT NULL, runtime TEXT NOT NULL, deployment TEXT NOT NULL, catalog TEXT NOT NULL REFERENCES catalogs(digest), client_name TEXT, client_version TEXT, pruned INTEGER NOT NULL DEFAULT 0, lost INTEGER NOT NULL DEFAULT 0)', + 'CREATE TABLE interactions (id TEXT PRIMARY KEY, session TEXT NOT NULL REFERENCES sessions(id), ordinal INTEGER NOT NULL, started REAL NOT NULL, method TEXT NOT NULL, operation TEXT NOT NULL, input_shape TEXT NOT NULL, shape_digest TEXT NOT NULL, discovery_operation TEXT, catalog_state TEXT NOT NULL, request_bytes INTEGER, scope TEXT NOT NULL, arguments TEXT NOT NULL, arguments_bytes INTEGER, thread TEXT, origin TEXT NOT NULL, UNIQUE(session, ordinal))', + "CREATE TABLE events (interaction TEXT PRIMARY KEY REFERENCES interactions(id) ON DELETE CASCADE, phase TEXT NOT NULL CHECK(phase IN ('end','error','incomplete')), finished REAL NOT NULL, duration_ms REAL NOT NULL, response_bytes INTEGER, outcome TEXT NOT NULL, feedback TEXT NOT NULL, result TEXT NOT NULL, result_bytes INTEGER)", 'CREATE INDEX interaction_age ON interactions(started)', ) +def default_database() -> Path: + """${XDG_DATA_HOME:-~/.local/share}/standards-engine/observations/.""" + base = os.environ.get('XDG_DATA_HOME', '') + base = Path(base) if os.path.isabs(base) else Path.home() / '.local' / 'share' + return base / 'standards-engine' / 'observations' / DEFAULT_DATABASE_NAME + + def _json(value: object) -> str: return json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':')) @@ -84,12 +148,158 @@ def _kind(value: object) -> str: return 'object' if isinstance(value, dict) else 'array' if isinstance(value, list) else 'unknown' +def _number(value: object) -> bool: + return isinstance(value, (int, float)) and not isinstance(value, bool) and abs(value) < 2 ** 53 + + +def _identifier(value: object) -> bool: + """A canonical identifier or enum word. Prose, digests and handle ids never match.""" + return isinstance(value, str) and bool(IDENTIFIER.fullmatch(value)) and not OPAQUE.search(value) + + +def _identifiers(values: Iterable[object]) -> list: + return [value for value in islice(values, MAX_RESULT_IDS) if _identifier(value)] + + +def _label(value: object) -> str | None: + """A client's self-reported name or version: bounded printable ASCII.""" + return re.sub(r'[^ -~]', '?', value)[:64] if isinstance(value, str) and value else None + + +def _sent(value: object, depth: int = 0) -> object: + """A caller value as sent, bounded. Cut strings and containers carry a marker.""" + if isinstance(value, str): + return value if len(value) <= MAX_VALUE_CHARS else value[:MAX_VALUE_CHARS] + TRUNCATED + if value is None or isinstance(value, bool) or _number(value): + return value + if isinstance(value, list) and depth < MAX_VALUE_DEPTH: + kept = [_sent(item, depth + 1) for item in value[:MAX_VALUE_ITEMS]] + return kept + [TRUNCATED] if len(value) > MAX_VALUE_ITEMS else kept + if isinstance(value, dict) and depth < MAX_VALUE_DEPTH: + kept = {_sent(str(name)): _sent(item, depth + 1) + for name, item in islice(value.items(), MAX_VALUE_ITEMS)} + if len(value) > MAX_VALUE_ITEMS: + kept[TRUNCATED] = len(value) - MAX_VALUE_ITEMS + return kept + return {'type': _kind(value)} + + +def _pick(value: object, names: tuple[str, ...]) -> dict: + """Allow-listed members as sent. A non-object keeps only its type.""" + if not isinstance(value, dict): + return {'type': _kind(value)} + return {name: _sent(value[name]) for name in names if name in value} + + +def _snapshot(handle: object) -> str: + """Reuse is visible through a short stable hash; the handle id is not kept.""" + identity = handle.get('id') if isinstance(handle, dict) else None + if not isinstance(identity, str): + return 'malformed' + return hashlib.sha256(identity.encode('utf-8', 'replace')).hexdigest()[:12] + + +def navigation_values(operation: str, arguments: dict) -> dict: + """The recorded values of one navigation call, from its explicit allow-list.""" + values = _pick(arguments, NAVIGATION[operation]) + if 'snapshot' in arguments: + values['snapshot'] = _snapshot(arguments['snapshot']) + handle = HANDLES.get(operation) + if handle in arguments: + values[handle] = _pick(arguments[handle], ('kind', 'child_kind')) + if operation == 'read_many' and isinstance(arguments.get('items'), list): + values['items'] = [_pick(item, _READ) for item in arguments['items'][:MAX_VALUE_ITEMS]] + if operation == 'route': + if 'content' in arguments: + values['content'] = _pick(arguments['content'], _PAGE) + if 'facts' in arguments: + # Names and values exactly as sent: invented facts are the signal. + values['facts'] = _sent(arguments['facts']) + request = arguments.get('request') + if operation in ('query', 'query_proposal', 'preview_application') and isinstance(request, dict): + kind = request.get('kind') + values['request'] = _pick(request, REQUESTS.get(kind if isinstance(kind, str) else '', ('kind',))) + if 'facts' in request: + values['request']['facts'] = _sent(request['facts']) + return values + + +def _recorded_facts(values: dict) -> dict: + """Route facts inside a recorded arguments object, top-level or in a nested request.""" + request = values.get('request') + facts = values.get('facts', request.get('facts') if isinstance(request, dict) else None) + return facts if isinstance(facts, dict) else {} + + +def _bounded(values: dict) -> dict: + """Whole-object cap: an oversized projection keeps its scalars and says so.""" + if len(_json(values)) <= MAX_ARGUMENT_BYTES: + return values + return {'truncated': True, **{name: value for name, value in values.items() + if not isinstance(value, (dict, list))}} + + +def _thread(meta: object) -> tuple[str | None, str]: + """Client thread id (hashed with the database salt before storage) and origin. + + Codex supplies both in x-codex-turn-metadata. No other _meta member is read, + so workspace paths, repository URLs, models and turn ids never reach storage. + """ + meta = meta if isinstance(meta, dict) else {} + turn = meta.get('x-codex-turn-metadata') + turn = turn if isinstance(turn, dict) else {} + candidates = (turn.get('thread_id'), meta.get('threadId'), turn.get('session_id'), meta.get('sessionId')) + identity = next((value[:MAX_THREAD_CHARS] for value in candidates + if isinstance(value, str) and value), None) + source = turn.get('thread_source') + origin = {'user': 'main', 'subagent': 'subagent'}.get(source, 'unknown') if isinstance(source, str) else 'unknown' + return identity, origin + + +def _returned(read: object) -> object: + """The canonical id a read result is about, wherever that result kind keeps it.""" + if not isinstance(read, dict): + return None + policy = read.get('policy') + if isinstance(policy, dict): + handle = policy.get('handle') + return policy.get('id') or (handle.get('child_id') if isinstance(handle, dict) else None) + return read.get('canonical_id') + + +def result_summary(value: dict) -> dict: + """Engine-produced identifiers and counts from structuredContent; never text.""" + summary = {} + for name, pattern in (('kind', RESULT_KIND), ('code', RESULT_CODE)): + if isinstance(value.get(name), str) and pattern.fullmatch(value[name]): + summary[name] = value[name] + for name in ('status', 'outcome'): + if isinstance(value.get(name), str) and value[name] in OUTCOMES: + summary[name] = value[name] + plan, questions, page = value.get('reading_plan'), value.get('unresolved_questions'), value.get('content') + if isinstance(plan, list): + summary['selected'] = _identifiers(entry.get('target') for entry in plan + if isinstance(entry, dict) and entry.get('state') == 'selected') + if isinstance(questions, list): + summary['unresolved'] = _identifiers(question['fact'].get('id') for question in questions + if isinstance(question, dict) and isinstance(question.get('fact'), dict)) + if isinstance(page, dict): # A route's content page. A read's content is text and is not inspected. + items = page.get('items') if isinstance(page.get('items'), list) else [] + summary['content'] = {**{name: page[name] for name in ('offset', 'total') if _number(page.get(name))}, + 'items': len(items), 'targets': _identifiers(map(_returned, items))} + reads = value['items'] if isinstance(value.get('items'), list) else [value] + targets = _identifiers(map(_returned, reads)) + if targets: + summary['targets'] = targets + return summary + + class InputShape: - """Value-free disclosure projection, not a second input validator. + """Disclosure projections of one operation's input, not a second validator. - Static property names come only from the installed schema. Unknown names and - every scalar value disappear before SQLite sees anything. Sensitive children - are not traversed even if their properties occur elsewhere in the schema. + Static property names come only from the installed schema. Unknown names + disappear before SQLite sees anything. Sensitive children are not traversed + even if their properties occur elsewhere in the schema. """ def __init__(self, schema: dict) -> None: self.schema = schema @@ -122,6 +332,7 @@ def _items(self, nodes: list[dict]) -> list[dict]: if isinstance(node.get('items'), dict)] def project(self, value: object) -> dict: + """Value-free structure: every scalar becomes only its type.""" budget = MAX_SHAPE_NODES def visit(item, nodes, depth): nonlocal budget @@ -156,7 +367,41 @@ def visit(item, nodes, depth): return {'type': _kind(value), 'truncated': True} return shape - def feedback(self, value: object) -> list[dict]: + def identifiers(self, value: object) -> dict: + """Authoring calls: identifiers and enums at schema-declared, allow-listed names. + + The walk follows project(): dynamic keys and sensitive subtrees are never + entered, nor are evidence references under their other name. A string + survives only if it has the shape of an identifier, so prose placed in an + identifier field is dropped like any body or rationale. + """ + budget = MAX_VALUE_NODES + def visit(item, nodes, name, depth): + nonlocal budget + budget -= 1 + if budget <= 0 or depth > 2 * MAX_SHAPE_DEPTH: + return None + if isinstance(item, dict): + properties, kept = self._properties(nodes), {} + for key, child in islice(item.items(), MAX_SHAPE_NODES): + if (key in properties and key.lower() not in SENSITIVE_FIELDS + and key != 'explicit_exclusions'): + found = visit(child, properties[key], key, depth + 1) + if found is not None and found != {} and found != []: + kept[key] = found + return kept + if isinstance(item, list): + children = self._items(nodes) + found = [visit(child, children, name, depth + 1) for child in item[:MAX_VALUE_ITEMS]] + return [entry for entry in found if entry is not None and entry != {} and entry != []] + if name in IDENTIFIER_FIELDS and (isinstance(item, bool) or _number(item) or _identifier(item)): + return item + return None + found = visit(value, [self.schema], '', 0) + return found if isinstance(found, dict) else {} + + def feedback(self, value: object, names: frozenset = frozenset()) -> list[dict]: + """Validation locations. `names` are route fact names this call already recorded.""" if not isinstance(value, dict) or not isinstance(value.get('issues'), list): return [] result = [] @@ -174,7 +419,8 @@ def feedback(self, value: object) -> list[dict]: safe.append(name.replace('~', '~0').replace('/', '~1')) nodes = [] if name.lower() in SENSITIVE_FIELDS else properties[name] else: - safe.append('*') + known = bool(safe) and safe[-1] == 'facts' and name in names + safe.append(name.replace('~', '~0').replace('/', '~1') if known else '*') nodes = items if part.isdecimal() else [] keyword = issue.get('keyword') result.append({'pointer': '/' + '/'.join(safe) if safe else '', @@ -184,8 +430,8 @@ def feedback(self, value: object) -> list[dict]: @dataclass(frozen=True) class RecorderConfig: - database: Path - deployment: str + database: Path | None = None # None selects default_database(). + deployment: str = DEFAULT_DEPLOYMENT max_calls: int = DEFAULT_MAX_CALLS max_age_seconds: int = DEFAULT_MAX_AGE_SECONDS max_bytes: int = DEFAULT_MAX_BYTES @@ -206,12 +452,37 @@ class Observation: identity: str started: float operation: str + facts: frozenset = frozenset() class StorageRejected(Exception): """Fixed operator code; never includes paths, SQL or payloads.""" +def _busy(error: Exception) -> bool: + return (isinstance(error, sqlite3.Error) and getattr(error, 'sqlite_errorcode', 0) & 255 + in (sqlite3.SQLITE_BUSY, sqlite3.SQLITE_LOCKED)) + + +def _deadline(wait_ms: int) -> float: + return time.monotonic() + wait_ms / 1000 + + +def _locked(db: sqlite3.Connection, deadline: float, statement: str = 'BEGIN IMMEDIATE') -> sqlite3.Cursor: + """Run a statement that needs the write lock, polling until the deadline. + + SQLite's own busy handler backs off in steps of up to 25 ms, far coarser than + a lock that other recorders hold for microseconds, so connections use none. + """ + while True: + try: + return db.execute(statement) + except sqlite3.OperationalError as error: + if not _busy(error) or time.monotonic() >= deadline: + raise + time.sleep(LOCK_POLL_SECONDS) + + class InteractionRecorder: def __init__(self, config: RecorderConfig, runtime: dict, catalog: list[dict], *, diagnostics: TextIO | None = None) -> None: @@ -219,57 +490,79 @@ def __init__(self, config: RecorderConfig, runtime: dict, catalog: list[dict], self.runtime = dict(runtime) self._diagnostics = diagnostics if diagnostics is not None else sys.stderr self._connection: sqlite3.Connection | None = None + self._salt = b'' + self._pages = 0 self._active: dict[str, Observation] = {} + self._backlog: deque[tuple[str, tuple]] = deque() + self._unsaved_lost = 0 + self._started = time.time() + self._client: tuple[str | None, str | None] = (None, None) self._sequence = 0 self._closed = False + self._silent = True self.health = {'state': 'starting', 'reason': None, 'recorded_starts': 0, - 'recorded_terminals': 0, 'dropped_observations': 0, + 'recorded_terminals': 0, 'backlog': 0, 'lost': 0, 'pruned_interactions': 0} self._shapes = {tool['name']: InputShape(tool['inputSchema']) for tool in catalog} - self._catalog = {tool['name']: { + self._catalog = _json({tool['name']: { 'input_digest': _digest(tool['inputSchema']), 'output_digest': (tool.get('_meta', {}).get('standards-engine/output-schema-digest') or _digest(tool.get('outputSchema'))), - } for tool in catalog} + } for tool in catalog}) try: - self._open() - self.health['state'] = 'healthy' - self._emit() + self._connection = self._open(_deadline(OPEN_TIMEOUT_MS)) + self._note('healthy') except Exception as error: self._degrade(error) def _emit(self) -> None: + self._silent = False try: print('standards-engine observer ' + _json(self.health), file=self._diagnostics, flush=True) except Exception: # Operator stderr can itself be broken. Never change a domain result. pass + def _note(self, state: str, reason: str | None = None) -> None: + """Operator stderr only when health changes; a healthy recorder is silent.""" + previous = (self.health['state'], self.health['reason']) + self.health.update(state=state, reason=reason, backlog=len(self._backlog)) + if previous != (state, reason) and 'degraded' in (previous[0], state): + self._emit() + def _degrade(self, error: Exception) -> None: + """Keep the backlog. Reconnect on a later call unless the database was only busy.""" reason = 'storage-unavailable' if isinstance(error, StorageRejected): reason = str(error) + elif _busy(error): + reason = 'storage-locked' elif isinstance(error, sqlite3.Error): - reason = {sqlite3.SQLITE_BUSY: 'storage-locked', sqlite3.SQLITE_LOCKED: 'storage-locked', - sqlite3.SQLITE_FULL: 'storage-full', sqlite3.SQLITE_CORRUPT: 'storage-corrupt', + reason = {sqlite3.SQLITE_FULL: 'storage-full', sqlite3.SQLITE_CORRUPT: 'storage-corrupt', sqlite3.SQLITE_NOTADB: 'storage-corrupt'}.get( getattr(error, 'sqlite_errorcode', 0) & 255, 'storage-error') - self.health.update(state='degraded', reason=reason) - self.health['dropped_observations'] += 1 - if self._connection is not None: + if reason != 'storage-locked' and self._connection is not None: try: self._connection.close() except Exception: pass self._connection = None - self._emit() + self._note('degraded', reason) - def _open(self) -> None: - path = self.config.database + def _lose(self, rows: int) -> None: + self.health['lost'] += rows + self._unsaved_lost += rows + + def _open(self, deadline: float) -> sqlite3.Connection: if os.name != 'posix': raise StorageRejected('unsupported-filesystem') - # The operator owns the existing directory; no recursive mkdir or changes - # to existing paths/permissions. O_NOFOLLOW protects the final component. + path = self.config.database + if path is None: + # Only the default location is created. An operator-supplied directory + # must already exist; existing paths and permissions are never changed. + path = default_database() + path.parent.mkdir(mode=0o700, parents=True, exist_ok=True) + # O_NOFOLLOW protects the final component. descriptor = os.open(path, os.O_RDWR | os.O_CREAT | os.O_NOFOLLOW, 0o600) try: info = os.fstat(descriptor) @@ -277,78 +570,153 @@ def _open(self) -> None: raise StorageRejected('unsafe-database-file') finally: os.close(descriptor) - db = sqlite3.connect(path, timeout=BUSY_TIMEOUT_MS / 1000, isolation_level=None) - self._connection = db - db.execute('PRAGMA foreign_keys=ON') - db.execute(f'PRAGMA busy_timeout={BUSY_TIMEOUT_MS}') - db.execute('BEGIN IMMEDIATE') + db = sqlite3.connect(path, timeout=0, isolation_level=None) try: - # Reject unsupported capabilities before publishing a migration. - if db.execute('PRAGMA journal_mode').fetchone()[0] != 'delete': + db.execute('PRAGMA foreign_keys=ON') + _locked(db, deadline) + try: + # Reject unsupported capabilities before publishing a migration. + pages = self.config.max_bytes // db.execute('PRAGMA page_size').fetchone()[0] + if db.execute('PRAGMA page_count').fetchone()[0] > pages: + raise StorageRejected('database-over-budget') + db.execute(f'PRAGMA max_page_count={pages}') + version = db.execute('PRAGMA user_version').fetchone()[0] + app = db.execute('PRAGMA application_id').fetchone()[0] + tables = db.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall() + if version == 0 and app == 0 and not tables: + # Table absence cannot prove privacy: dropped SQLite content may + # remain in freelist pages or sqlite_master slack. Only a truly + # new zero-length source is admitted; never wipe/reuse old bytes. + # Simultaneous creators queue on this lock: the first publishes + # the whole schema in one commit and the rest find it complete. + if info.st_size != 0 or path.stat().st_size != 0: + raise StorageRejected('nonpristine-database') + for statement in SCHEMA_DDL: + db.execute(statement) + db.execute("INSERT INTO meta VALUES('salt',?)", (secrets.token_hex(16),)) + db.execute(f'PRAGMA application_id={APPLICATION_ID}') + db.execute(f'PRAGMA user_version={SCHEMA_VERSION}') + elif version != SCHEMA_VERSION or app != APPLICATION_ID: + # Includes schema v1: historical evidence, never migrated or deleted. + raise StorageRejected('unsupported-database-schema') + actual = {row[0]: row[1] for row in db.execute( + "SELECT name,sql FROM sqlite_master WHERE name NOT LIKE 'sqlite_%'")} + expected = {statement.split()[2]: statement for statement in SCHEMA_DDL} + if actual != expected: + raise StorageRejected('invalid-database-schema') + salt = bytes.fromhex(db.execute("SELECT value FROM meta WHERE key='salt'").fetchone()[0]) + _locked(db, deadline, 'COMMIT') + except BaseException: + db.execute('ROLLBACK') + raise + # WAL keeps the write lock to microseconds (no fsync per commit) and lets + # a report read while servers write. Idempotent for every later opener. + if _locked(db, deadline, 'PRAGMA journal_mode=WAL').fetchone()[0] != 'wal': raise StorageRejected('unsupported-journal-mode') - pages = self.config.max_bytes // db.execute('PRAGMA page_size').fetchone()[0] - if db.execute('PRAGMA page_count').fetchone()[0] > pages: - raise StorageRejected('database-over-budget') - db.execute(f'PRAGMA max_page_count={pages}') - version = db.execute('PRAGMA user_version').fetchone()[0] - app = db.execute('PRAGMA application_id').fetchone()[0] - tables = db.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall() - if version == 0 and app == 0 and not tables: - # Table absence cannot prove privacy: dropped SQLite content may - # remain in freelist pages or sqlite_master slack. Only a truly - # new zero-length source is admitted; never wipe/reuse old bytes. - if info.st_size != 0 or path.stat().st_size != 0: - raise StorageRejected('nonpristine-database') - for statement in SCHEMA_DDL: - db.execute(statement) - db.execute(f'PRAGMA application_id={APPLICATION_ID}') - db.execute(f'PRAGMA user_version={SCHEMA_VERSION}') - elif version != SCHEMA_VERSION or app != APPLICATION_ID: - raise StorageRejected('unsupported-database-schema') - actual = {row[0]: row[1] for row in db.execute( - "SELECT name,sql FROM sqlite_master WHERE name NOT LIKE 'sqlite_%'")} - expected = {statement.split()[2]: statement for statement in SCHEMA_DDL} - if actual != expected: - raise StorageRejected('invalid-database-schema') - db.execute('COMMIT') + db.execute('PRAGMA synchronous=NORMAL') + db.execute('PRAGMA secure_delete=ON') except BaseException: - db.execute('ROLLBACK') + db.close() raise - db.execute('PRAGMA synchronous=FULL') - db.execute('PRAGMA secure_delete=ON') - - def _transaction(self, action): - db = self._connection - if db is None: - self.health['dropped_observations'] += 1 - return False + self._salt, self._pages = salt, pages + return db + + def _pseudonym(self, thread: str | None) -> str | None: + if thread is None: + return None + return hmac.new(self._salt, thread.encode('utf-8', 'replace'), 'sha256').hexdigest()[:16] + + def _write(self, db: sqlite3.Connection) -> tuple[Counter, int, int]: + """One transaction: prune to policy, then store the whole backlog in order.""" + session, now = self.runtime['instance_id'], time.time() + starts = sum(kind == 'start' for kind, _ in self._backlog) + pruned = 0 + if starts: + pruned = db.execute('DELETE FROM interactions WHERE started < ?', + (now - self.config.max_age_seconds,)).rowcount + count = db.execute('SELECT count(*) FROM interactions').fetchone()[0] + excess = max(0, count + starts - self.config.max_calls) + used = db.execute('PRAGMA page_count').fetchone()[0] - db.execute('PRAGMA freelist_count').fetchone()[0] + if used > self._pages - self._pages // 16: + # The byte cap bounds retention like the count cap: a nearly full file + # gives up its oldest sixteenth instead of refusing new observations. + excess = max(excess, count // 16 + starts) + if excess: + pruned += db.execute('DELETE FROM interactions WHERE id IN ' + '(SELECT id FROM interactions ORDER BY started,id LIMIT ?)', (excess,)).rowcount + if pruned: + # A session that only carries a loss count stays until it ages out. + db.execute('DELETE FROM sessions WHERE id != ? AND (lost = 0 OR started < ?) AND NOT EXISTS ' + '(SELECT 1 FROM interactions WHERE session=sessions.id)', + (session, now - self.config.max_age_seconds)) + db.execute('DELETE FROM catalogs WHERE digest NOT IN (SELECT catalog FROM sessions)') + catalog = _digest(self._catalog) + db.execute('INSERT OR IGNORE INTO catalogs VALUES(?,?)', (catalog, self._catalog)) + db.execute('INSERT OR IGNORE INTO sessions(id,started,runtime,deployment,catalog) VALUES(?,?,?,?,?)', + (session, self._started, _json(self.runtime), self.config.deployment, catalog)) + recorded = Counter() + for kind, row in self._backlog: + if kind == 'start': + recorded[kind] += db.execute( + 'INSERT OR IGNORE INTO interactions VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)', + (*row[:-2], self._pseudonym(row[-2]), row[-1])).rowcount + else: + # Retention or a backlog overflow may have removed this start. Do + # not recreate it or claim a terminal event was retained. + recorded[kind] += db.execute( + 'INSERT OR IGNORE INTO events SELECT ?,?,?,?,?,?,?,?,? WHERE EXISTS ' + '(SELECT 1 FROM interactions WHERE id=?)', (*row, row[0])).rowcount + orphans = len(self._backlog) - starts - recorded['end'] + db.execute('UPDATE sessions SET client_name=?,client_version=?,pruned=pruned+?,lost=lost+? WHERE id=?', + (*self._client, pruned, self._unsaved_lost + orphans, session)) + return recorded, pruned, orphans + + def _flush(self, wait_ms: int) -> None: + """Deliver the backlog, or keep all of it for a later call. Never raises.""" + if not self._backlog and not self._unsaved_lost: + return + deadline = _deadline(wait_ms) try: - db.execute('BEGIN IMMEDIATE') - action(db) - db.execute('COMMIT') - return True - except Exception as error: + if self._connection is None: + self._connection = self._open(deadline) + db = self._connection + _locked(db, deadline) try: - db.execute('ROLLBACK') - except sqlite3.Error: - pass + recorded, pruned, orphans = self._write(db) + db.execute('COMMIT') + except BaseException: + try: + db.execute('ROLLBACK') + except sqlite3.Error: + pass + raise + except Exception as error: self._degrade(error) - return False + return + self._backlog.clear() + self._unsaved_lost = 0 + self.health['recorded_starts'] += recorded['start'] + self.health['recorded_terminals'] += recorded['end'] + self.health['pruned_interactions'] += pruned + self.health['lost'] += orphans + self._note('healthy') + + def _record(self, kind: str, row: tuple) -> None: + if len(self._backlog) >= MAX_BACKLOG: + # Bounded memory: the oldest waiting row gives way and is counted. + self._backlog.popleft() + self._lose(1) + self._backlog.append((kind, row)) + self._flush(BUSY_TIMEOUT_MS) def begin(self, message: object, *, request_bytes: int | None, scope: str, parse_error: bool = False) -> Observation | None: if self._closed: return None - if self._active: - self._degrade(StorageRejected('overlapping-recorder-call')) - return None # Notifications have no response pair. Invalid envelopes and parse errors do. if (isinstance(message, dict) and 'id' not in message and not parse_error and message.get('jsonrpc') == '2.0' and isinstance(message.get('method'), str)): return None - if self._connection is None: - self.health['dropped_observations'] += 1 - return None try: params = message.get('params', {}) if isinstance(message, dict) else {} params = params if isinstance(params, dict) else {} @@ -356,43 +724,41 @@ def begin(self, message: object, *, request_bytes: int | None, scope: str, method = method if isinstance(method, str) and method in METHODS else 'invalid-json' if parse_error else 'other' name = params.get('name') operation = name if method == 'tools/call' and isinstance(name, str) and name in self._shapes else 'other' - shape = self._shapes[operation].project(params.get('arguments', {})) if operation in self._shapes else {} arguments = params.get('arguments', {}) + shape, values, arguments_bytes = {}, {}, None + if operation in self._shapes: + shape = self._shapes[operation].project(arguments) + if operation not in NAVIGATION: + values = self._shapes[operation].identifiers(arguments) + elif isinstance(arguments, dict): + values = navigation_values(operation, arguments) + values = _bounded(values) + try: + arguments_bytes = len(json.dumps(arguments, ensure_ascii=False, separators=(',', ':')).encode('utf-8')) + except Exception: + pass discovery = arguments.get('operation') if isinstance(arguments, dict) else None discovery = discovery if operation in {'describe_input', 'describe_output'} and isinstance(discovery, str) and discovery in self._shapes else None expected = arguments.get('expected_catalog') if isinstance(arguments, dict) else None catalog_state = ('unspecified' if expected is None else 'matches' if expected == self.runtime['catalog_digest'] else 'differs') - now = time.time() - observation = Observation(str(uuid.uuid4()), time.monotonic(), operation) + if method == 'initialize' and self._client == (None, None): + client = params.get('clientInfo') + client = client if isinstance(client, dict) else {} + self._client = (_label(client.get('name')), _label(client.get('version'))) + thread, origin = _thread(params.get('_meta')) + observation = Observation(str(uuid.uuid4()), time.monotonic(), operation, + frozenset(_recorded_facts(values))) self._sequence += 1 - pruned = 0 - def write(db): - nonlocal pruned - db.execute('INSERT OR IGNORE INTO sessions(id,started,runtime,deployment,catalog) VALUES(?,?,?,?,?)', - (self.runtime['instance_id'], now, _json(self.runtime), self.config.deployment, _json(self._catalog))) - pruned += db.execute('DELETE FROM interactions WHERE started < ?', - (now - self.config.max_age_seconds,)).rowcount - excess = db.execute('SELECT max(0,count(*)-?) FROM interactions', - (self.config.max_calls - 1,)).fetchone()[0] - if excess: - pruned += db.execute('DELETE FROM interactions WHERE id IN ' - '(SELECT id FROM interactions ORDER BY started,id LIMIT ?)', (excess,)).rowcount - db.execute('DELETE FROM sessions WHERE id != ? AND NOT EXISTS ' - '(SELECT 1 FROM interactions WHERE session=sessions.id)', (self.runtime['instance_id'],)) - db.execute('UPDATE sessions SET pruned=pruned+? WHERE id=?', (pruned, self.runtime['instance_id'])) - db.execute('INSERT INTO interactions VALUES(?,?,?,?,?,?,?,?,?,?,?,?)', - (observation.identity, self.runtime['instance_id'], self._sequence, now, - method, operation, _json(shape), _digest(shape), discovery, catalog_state, - request_bytes, scope)) - if not self._transaction(write): - return None - self.health['recorded_starts'] += 1 - self.health['pruned_interactions'] += pruned + row = (observation.identity, self.runtime['instance_id'], self._sequence, time.time(), + method, operation, _json(shape), _digest(shape), discovery, catalog_state, + request_bytes, scope, _json(values), arguments_bytes, thread, origin) self._active[observation.identity] = observation + self._record('start', row) return observation - except Exception as error: - self._degrade(error) + except Exception: + self._lose(1) + self._note('degraded', 'recorder-error') return None def finish(self, observation: Observation | None, response: object = None, @@ -401,7 +767,7 @@ def finish(self, observation: Observation | None, response: object = None, return self._active.pop(observation.identity, None) try: - phase, outcome, feedback = 'end', 'response', [] + phase, outcome, feedback, summary, result_bytes = 'end', 'response', [], {}, None if incomplete: phase, outcome = 'incomplete', 'unknown' elif isinstance(response, dict): @@ -421,30 +787,24 @@ def finish(self, observation: Observation | None, response: object = None, outcome = value['outcome'] elif isinstance(value.get('status'), str) and value['status'] in OUTCOMES: outcome = value['status'] + summary = result_summary(value) + if 'structuredContent' in result: + try: + # One serialization: the text copy the transport already made. + result_bytes = len(result['content'][0]['text'].encode('utf-8')) + except Exception: + pass if observation.operation in self._shapes: - feedback = self._shapes[observation.operation].feedback(value.get('input_feedback')) + feedback = self._shapes[observation.operation].feedback( + value.get('input_feedback'), observation.facts) if 'input_feedback' in value: phase, outcome = 'error', 'input-invalid' - evicted = False - def write(db): - nonlocal evicted - # Retention in another process may have evicted this start. Do not - # recreate it or claim a terminal event was retained. - if not db.execute('SELECT 1 FROM interactions WHERE id=?', (observation.identity,)).fetchone(): - evicted = True - return - db.execute('INSERT INTO events VALUES(?,?,?,?,?,?,?)', - (observation.identity, phase, time.time(), - max(0, (time.monotonic() - observation.started) * 1000), - response_bytes, outcome, _json(feedback))) - if self._transaction(write): - if evicted: - self.health['dropped_observations'] += 1 - self._emit() - else: - self.health['recorded_terminals'] += 1 - except Exception as error: - self._degrade(error) + self._record('end', (observation.identity, phase, time.time(), + max(0, (time.monotonic() - observation.started) * 1000), + response_bytes, outcome, _json(feedback), _json(summary), result_bytes)) + except Exception: + self._lose(1) + self._note('degraded', 'recorder-error') def close(self) -> None: if self._closed: @@ -452,13 +812,22 @@ def close(self) -> None: for observation in tuple(self._active.values()): self.finish(observation, incomplete=True) self._closed = True + self._flush(CLOSE_TIMEOUT_MS) + if self._backlog: + # The process is ending: nothing can deliver these rows any more. + # Save the count if the database can still be reached at all. + self._lose(len(self._backlog)) + self._backlog.clear() + self._flush(BUSY_TIMEOUT_MS) if self._connection is not None: try: self._connection.close() - except Exception as error: - self._degrade(error) + except Exception: + pass self._connection = None - self._emit() + self.health['backlog'] = 0 + if not self._silent or self.health['lost']: + self._emit() def open_report(database: Path) -> sqlite3.Connection: @@ -476,38 +845,171 @@ def open_report(database: Path) -> sqlite3.Connection: raise -def report(database: Path, *, limit: int = 100) -> dict: +def _percentile(values: list, fraction: float): + ordered = sorted(values) + return ordered[max(0, math.ceil(fraction * len(ordered)) - 1)] if ordered else None + + +def _top(counter: Counter, limit: int, *names: str) -> list[dict]: + """Most common keys as rows; ties break on the key so reports are stable.""" + rows = sorted(counter.items(), key=lambda item: (-item[1], _json(item[0])))[:limit] + return [{**dict(zip(names, key if isinstance(key, tuple) else (key,))), 'count': count} + for key, count in rows] + + +def _fact_values(value: object) -> list[str]: + """The vocabulary words inside one routing fact value as sent.""" + if isinstance(value, dict): # Native typed form {type, state, value}. + value = value.get('value') + return [item for item in (value if isinstance(value, list) else [value]) if isinstance(item, str)] + + +def _usage(db: sqlite3.Connection, since: float, limit: int) -> dict: + """What agents asked for and what came back, from the recorded values.""" + sessions = {} + for row in db.execute('SELECT id,runtime,client_name,client_version FROM sessions'): + runtime = json.loads(row['runtime']) + sessions[row['id']] = (' '.join(filter(None, (row['client_name'], row['client_version']))) or 'unknown', + runtime.get('purpose'), runtime.get('interface_version')) + clients, calls, rejected = {}, Counter(), Counter() + durations, sizes = {}, {} + rejections, read_targets, origins, tool_calls = Counter(), Counter(), {}, Counter() + reads, accepted, declared, refused = {}, {}, set(), [] + routes = without_snapshot = 0 + for row in db.execute( + 'SELECT i.session,i.method,i.operation,i.arguments,i.thread,i.origin,e.phase,e.outcome,' + 'e.feedback,e.duration_ms,e.result,e.result_bytes FROM interactions i LEFT JOIN events e ' + 'ON e.interaction=i.id WHERE i.started >= ? ORDER BY i.started,i.id', (since,)): + client = clients.setdefault(sessions.get(row['session'], ('unknown', None, None)), [set(), 0]) + client[0].add(row['session']) + client[1] += 1 + thread = row['thread'] or 'process:' + row['session'] + if row['method'] == 'tools/call': + origins[thread] = row['origin'] + tool_calls[thread] += 1 + operation = row['operation'] if row['method'] == 'tools/call' else row['method'] + calls[operation] += 1 + if row['duration_ms'] is not None: + durations.setdefault(operation, []).append(row['duration_ms']) + if row['result_bytes'] is not None: + sizes.setdefault(operation, []).append(row['result_bytes']) + arguments = json.loads(row['arguments']) + result = json.loads(row['result']) if row['result'] else {} + facts = _recorded_facts(arguments) + if row['operation'] == 'route': + routes += 1 + without_snapshot += 'snapshot' not in arguments + if row['phase'] == 'end': + declared.update(result.get('unresolved', ())) + for name, value in facts.items(): + accepted.setdefault(name, set()).update(_fact_values(value)) + delivered = result.get('targets', []) + result.get('content', {}).get('targets', []) + read_targets.update(delivered) + if delivered: + reads.setdefault(thread, Counter()).update(delivered) + elif row['phase'] == 'error' and row['method'] == 'tools/call': + rejected[operation] += 1 + issue = (json.loads(row['feedback']) or [{}])[0] + # The offending value is whatever the validation pointer names in the + # recorded arguments; without a pointer, everything recorded but the snapshot. + value = arguments + for part in issue.get('pointer', '').split('/')[1:]: + part = part.replace('~1', '/').replace('~0', '~') + inner = (value.get(part) if isinstance(value, dict) + else value[int(part)] if isinstance(value, list) and part.isdecimal() and int(part) < len(value) + else None) + if inner is None: + break + value = inner + if value is arguments: + value = {name: item for name, item in arguments.items() if name != 'snapshot'} + rejections[(operation, result.get('code') or row['outcome'], issue.get('pointer', ''), + issue.get('keyword', ''), _json(value)[:MAX_VALUE_CHARS])] += 1 + if issue.get('keyword') == 'fact': + pointed = issue['pointer'].rpartition('/facts/')[2].replace('~1', '/').replace('~0', '~') + refused.append((facts, pointed if '/facts/' in issue['pointer'] else None)) + # Out-of-vocabulary is inferred, never looked up: a name or value counts when + # the server refused its route and never accepted or asked for it in this window. + names, values = Counter(), Counter() + for facts, pointed in refused: + names.update(name for name in facts if name not in accepted and name not in declared) + for name in ([pointed] if pointed in facts else []): + values.update((name, word) for word in _fact_values(facts[name]) + if word not in accepted.get(name, ())) + repeats = {thread: sum(seen.values()) - len(seen) for thread, seen in reads.items()} + total_reads = sum(sum(seen.values()) for seen in reads.values()) + threads = {} + for thread, origin in origins.items(): + entry = threads.setdefault(origin, {'origin': origin, 'threads': 0, 'calls': 0, 'reads': 0, 'repeats': 0}) + entry['threads'] += 1 + entry['calls'] += tool_calls[thread] + entry['reads'] += sum(reads.get(thread, {}).values()) + entry['repeats'] += repeats.get(thread, 0) + return { + 'clients': [{'client': key[0], 'purpose': key[1], 'interface_version': key[2], + 'sessions': len(value[0]), 'calls': value[1]} + for key, value in sorted(clients.items(), key=lambda item: (-item[1][1], _json(item[0])))][:limit], + 'usage': [{'operation': operation, 'calls': count, 'rejected': rejected[operation], + 'rejection_rate': rejected[operation] / count, + 'duration_p50_ms': _percentile(durations.get(operation, []), 0.5), + 'duration_p90_ms': _percentile(durations.get(operation, []), 0.9), + 'duration_max_ms': max(durations.get(operation, []), default=None), + 'result_p50_bytes': _percentile(sizes.get(operation, []), 0.5), + 'result_max_bytes': max(sizes.get(operation, []), default=None)} + for operation, count in sorted(calls.items(), key=lambda item: (-item[1], item[0]))][:limit], + 'rejections': _top(rejections, limit, 'operation', 'code', 'pointer', 'keyword', 'value'), + 'unaccepted_facts': {'names': _top(names, limit, 'name'), 'values': _top(values, limit, 'fact', 'value')}, + 'read_targets': _top(read_targets, limit, 'target'), + 'repeat_reads': {'reads': total_reads, 'repeats': sum(repeats.values()), 'threads': len(reads), + 'threads_repeating': sum(count > 0 for count in repeats.values()), + 'worst_thread_rate': max((count / sum(reads[thread].values()) + for thread, count in repeats.items() if count), default=0.0)}, + 'routes': {'calls': routes, 'without_snapshot': without_snapshot}, + 'threads': [threads[origin] for origin in sorted(threads)], + } + + +def report(database: Path, *, limit: int = 100, since_days: float | None = None) -> dict: if not 1 <= limit <= MAX_REPORT_ROWS: raise ValueError('report limit must be in 1..1000') + if since_days is not None and not 0 < since_days <= 3650: + raise ValueError('since_days must be in 0..3650') + since = time.time() - since_days * 24 * 60 * 60 if since_days is not None else 0.0 db = open_report(database) db.row_factory = sqlite3.Row try: db.execute('BEGIN') # One consistent read snapshot, including denominators. - total = db.execute('SELECT count(*) FROM interactions').fetchone()[0] - terminals = db.execute('SELECT count(*) FROM events').fetchone()[0] + total, first, last = db.execute('SELECT count(*),min(started),max(started) FROM interactions ' + 'WHERE started >= ?', (since,)).fetchone() + terminals = db.execute('SELECT count(*) FROM events e JOIN interactions i ON i.id=e.interaction ' + 'WHERE i.started >= ?', (since,)).fetchone()[0] + lost, pruned = db.execute('SELECT coalesce(sum(lost),0),coalesce(sum(pruned),0) FROM sessions').fetchone() operations = [dict(row) for row in db.execute( 'SELECT i.scope,i.method,i.operation,count(*) AS starts,count(e.interaction) AS terminals,' 'sum(CASE WHEN e.phase=\'error\' THEN 1 ELSE 0 END) AS errors,' 'sum(CASE WHEN e.interaction IS NULL OR e.phase=\'incomplete\' THEN 1 ELSE 0 END) AS incomplete,' 'sum(i.request_bytes) AS request_bytes,count(i.request_bytes) AS request_measurements,' + 'sum(i.arguments_bytes) AS arguments_bytes,count(i.arguments_bytes) AS arguments_measurements,' 'sum(e.response_bytes) AS response_bytes,count(e.response_bytes) AS response_measurements,' + 'sum(e.result_bytes) AS result_bytes,count(e.result_bytes) AS result_measurements,' 'count(e.duration_ms) AS duration_measurements,' 'avg(e.duration_ms) AS observed_duration_ms FROM interactions i LEFT JOIN events e ' - 'ON e.interaction=i.id GROUP BY i.scope,i.method,i.operation ORDER BY starts DESC,i.scope,i.method,i.operation LIMIT ?', (limit + 1,))] + 'ON e.interaction=i.id WHERE i.started >= ? GROUP BY i.scope,i.method,i.operation ' + 'ORDER BY starts DESC,i.scope,i.method,i.operation LIMIT ?', (since, limit + 1))] operations_truncated = len(operations) > limit operations = operations[:limit] failures = [dict(row) for row in db.execute( 'SELECT i.scope,i.operation,i.shape_digest,e.outcome,e.feedback,count(*) AS count FROM interactions i ' - 'JOIN events e ON e.interaction=i.id WHERE e.phase=\'error\' ' - 'GROUP BY i.scope,i.operation,i.shape_digest,e.outcome,e.feedback ORDER BY count DESC,i.scope,i.operation,i.shape_digest,e.outcome,e.feedback LIMIT ?', (limit + 1,))] + 'JOIN events e ON e.interaction=i.id WHERE e.phase=\'error\' AND i.started >= ? ' + 'GROUP BY i.scope,i.operation,i.shape_digest,e.outcome,e.feedback ORDER BY count DESC,i.scope,i.operation,i.shape_digest,e.outcome,e.feedback LIMIT ?', (since, limit + 1))] failures_truncated = len(failures) > limit failures = failures[:limit] shapes = [dict(row) for row in db.execute( 'SELECT i.scope,i.operation,i.shape_digest,i.input_shape,count(*) AS starts,' 'sum(CASE WHEN e.phase=\'error\' THEN 1 ELSE 0 END) AS errors FROM interactions i ' - 'LEFT JOIN events e ON e.interaction=i.id WHERE i.method=\'tools/call\' ' + 'LEFT JOIN events e ON e.interaction=i.id WHERE i.method=\'tools/call\' AND i.started >= ? ' 'GROUP BY i.scope,i.operation,i.shape_digest,i.input_shape ' - 'ORDER BY starts DESC,i.scope,i.operation,i.shape_digest LIMIT ?', (limit + 1,))] + 'ORDER BY starts DESC,i.scope,i.operation,i.shape_digest LIMIT ?', (since, limit + 1))] shapes_truncated = len(shapes) > limit shapes = shapes[:limit] for shape in shapes: @@ -518,7 +1020,6 @@ def report(database: Path, *, limit: int = 100) -> dict: 'SELECT * FROM (SELECT * FROM sessions ORDER BY started DESC,id DESC LIMIT ?) ORDER BY started,id', (limit,))] for session in sessions: session['runtime'] = json.loads(session['runtime']) - session['catalog'] = json.loads(session['catalog']) # Chronology within a process only: these are observed attempts, not proof # of agent intent, a repair relation, or an acquired definition. pending = Counter() @@ -529,8 +1030,8 @@ def report(database: Path, *, limit: int = 100) -> dict: scanned = 0 for row in db.execute( 'SELECT * FROM (SELECT i.session,i.ordinal,i.scope,i.operation,i.discovery_operation,e.phase ' - 'FROM interactions i LEFT JOIN events e ON e.interaction=i.id ' - 'ORDER BY i.started DESC,i.id DESC LIMIT ?) ORDER BY session,ordinal', (MAX_SEQUENCE_SCAN,)): + 'FROM interactions i LEFT JOIN events e ON e.interaction=i.id WHERE i.started >= ? ' + 'ORDER BY i.started DESC,i.id DESC LIMIT ?) ORDER BY session,ordinal', (since, MAX_SEQUENCE_SCAN)): scanned += 1 scope = row['scope'] key = (row['session'], scope, row['operation']) @@ -551,20 +1052,26 @@ def report(database: Path, *, limit: int = 100) -> dict: 'preceding_errors_histogram': dict(sorted(errors.items())[:limit]), 'preceding_discoveries_histogram': dict(sorted(discovery.items())[:limit]), 'histograms_truncated': len(errors) > limit or len(discovery) > limit}) + # Each distinct catalog is stored once; compare them in order of first use. revisions = {} for session in sessions: - revisions.setdefault(session['runtime']['catalog_digest'], session['catalog']) + revisions.setdefault(session['runtime'].get('catalog_digest'), session['catalog']) + tools = {digest: json.loads(db.execute('SELECT tools FROM catalogs WHERE digest=?', (digest,)).fetchone()[0]) + for digest in set(revisions.values())} comparisons = [] digests = list(revisions) for before, after in zip(digests, digests[1:]): - left, right = revisions[before], revisions[after] + left, right = tools[revisions[before]], tools[revisions[after]] comparisons.append({'before': before, 'after': after, 'added': sorted(right.keys() - left.keys()), 'removed': sorted(left.keys() - right.keys()), 'changed': sorted(name for name in left.keys() & right.keys() if left[name] != right[name])}) - return {'schema_version': SCHEMA_VERSION, 'retained_starts': total, + return {'schema_version': SCHEMA_VERSION, 'since_days': since_days, + 'first_start': first, 'last_start': last, 'retained_starts': total, 'retained_terminals': terminals, 'unmatched_starts': total - terminals, + 'lost_rows': lost, 'pruned_interactions': pruned, + **_usage(db, since, limit), 'operations': operations, 'operations_truncated': operations_truncated, 'failures': failures, 'failures_truncated': failures_truncated, 'shapes': shapes, 'shapes_truncated': shapes_truncated, 'sessions': sessions, @@ -575,24 +1082,87 @@ def report(database: Path, *, limit: int = 100) -> dict: 'limits': {'group_rows': limit, 'sequence_scan_limit': MAX_SEQUENCE_SCAN, 'meaning': 'Retained observations only; unmatched or incomplete outcomes are unknown. ' 'End means response produced/delivered per scope, not domain completion. ' - 'Sequence denominator is end responses per session/scope/operation in the bounded scan. No cross-process ' - 'continuation or intent is inferred. Retention can remove prior attempts. ' + 'Sequence denominator is end responses per session/scope/operation in the bounded scan. ' + 'A thread is a hashed client thread id, or the server process when the client sent none. ' + 'Unaccepted facts are inferred from refused routes, not checked against a vocabulary. ' + 'Retention can remove prior attempts; lost_rows and pruned_interactions cover retained sessions. ' 'Bytes are serialized JSON/stdio bytes, never tokens or billing. ' - 'Redacted requests cannot be replayed; use independent qualification evidence.'}} + 'Recorded requests cannot be replayed; use independent qualification evidence.'}} finally: db.close() +def _stamp(seconds: float | None) -> str: + return datetime.fromtimestamp(seconds, timezone.utc).strftime('%Y-%m-%d %H:%M') if seconds else '-' + + +def _amount(value: float | None, unit: str = '') -> str: + if value is None: + return '-' + if unit == 'B': + return (f'{value} B' if value < 1000 else f'{value / 1000:.1f} kB' if value < 1_000_000 + else f'{value / 1_000_000:.1f} MB') + return f'{value:.1f}' if value < 10 else f'{value:.0f}' + + +def _share(part: int, whole: int) -> str: + return f'{part} of {whole} ({100 * part / whole:.1f}%)' if whole else '0 of 0' + + +def text_report(summary: dict) -> str: + """About a screenful for a person; the JSON form holds every row.""" + window = f'last {summary["since_days"]:g} days' if summary['since_days'] else 'all retained' + lines = [ + f'Standards Engine MCP observations, schema v{summary["schema_version"]} ({window})', + f'{_stamp(summary["first_start"])} to {_stamp(summary["last_start"])} UTC', + f'{summary["retained_starts"]} calls: {summary["unmatched_starts"]} without an outcome ' + f'(process ended mid-call), {summary["lost_rows"]} rows lost, ' + f'{summary["pruned_interactions"]} pruned by retention', + '', f'{"Client":<34}{"purpose":<13}{"interface":>9}{"sessions":>10}{"calls":>8}'] + lines += [f'{row["client"][:33]:<34}{row["purpose"] or "-":<13}{row["interface_version"] or "-":>9}' + f'{row["sessions"]:>10}{row["calls"]:>8}' for row in summary['clients'][:TEXT_ROWS]] + lines += ['', f'{"Operation":<22}{"calls":>7}{"rejected":>10}{"p50 ms":>9}{"p90 ms":>9}{"max ms":>9}' + f'{"p50 result":>12}{"max result":>12}'] + lines += [f'{row["operation"][:21]:<22}{row["calls"]:>7}{100 * row["rejection_rate"]:>9.1f}%' + f'{_amount(row["duration_p50_ms"]):>9}{_amount(row["duration_p90_ms"]):>9}' + f'{_amount(row["duration_max_ms"]):>9}{_amount(row["result_p50_bytes"], "B"):>12}' + f'{_amount(row["result_max_bytes"], "B"):>12}' for row in summary['usage'][:2 * TEXT_ROWS]] + lines += ['', 'Top rejections (count, operation, code, where, value sent)'] + lines += [f'{row["count"]:>5} {row["operation"]} {row["code"]} ' + f'{row["pointer"] or "-"}{" (" + row["keyword"] + ")" if row["keyword"] else ""} {row["value"][:70]}' + for row in summary['rejections'][:TEXT_ROWS]] or [' none'] + facts = summary['unaccepted_facts'] + lines += ['', 'Route facts the server refused and never accepted in this window', + ' names: ' + (', '.join(f'{row["name"][:40]} x{row["count"]}' for row in facts['names'][:TEXT_ROWS]) or 'none'), + ' values: ' + (', '.join(f'{row["fact"][:40]}={row["value"][:40]} x{row["count"]}' + for row in facts['values'][:TEXT_ROWS]) or 'none'), + '', 'Most-read targets (read, read_many and route content)', + ' ' + (', '.join(f'{row["target"]} x{row["count"]}' for row in summary['read_targets'][:TEXT_ROWS]) or 'none')] + repeats, routes = summary['repeat_reads'], summary['routes'] + lines += ['', f'Reads repeating a target within one thread: {_share(repeats["repeats"], repeats["reads"])}; ' + f'{repeats["threads_repeating"]} of {repeats["threads"]} reading threads repeated ' + f'(worst {100 * repeats["worst_thread_rate"]:.1f}%)', + f'Routes sent without a snapshot: {_share(routes["without_snapshot"], routes["calls"])}', + '', f'{"Tool-calling threads":<22}{"threads":>7}{"calls":>8} reads repeated'] + lines += [f'{row["origin"]:<22}{row["threads"]:>7}{row["calls"]:>8} {_share(row["repeats"], row["reads"])}' + for row in summary['threads']] + return '\n'.join(lines) + + def main() -> int: parser = argparse.ArgumentParser(description='Read-only operator MCP observation report; no agent tools.') - parser.add_argument('--database', type=Path, required=True) - parser.add_argument('--limit', type=int, default=100) + parser.add_argument('--database', type=Path, help='Defaults to the always-on recording location.') + parser.add_argument('--format', choices=('text', 'json'), default='text') + parser.add_argument('--since-days', type=float, help='Only calls started within this many days.') + parser.add_argument('--limit', type=int, default=100, help='Rows per section in the JSON form.') arguments = parser.parse_args() try: - print(json.dumps(report(arguments.database, limit=arguments.limit), sort_keys=True, indent=2)) - except (OSError, sqlite3.Error, StorageRejected, ValueError): + summary = report(arguments.database or default_database(), limit=arguments.limit, + since_days=arguments.since_days) + except (OSError, RuntimeError, sqlite3.Error, StorageRejected, ValueError): print('Observation report unavailable; check database access and schema.', file=sys.stderr) return 1 + print(json.dumps(summary, sort_keys=True, indent=2) if arguments.format == 'json' else text_report(summary)) return 0 diff --git a/tools/standards_engine/standards_engine/mcp.py b/tools/standards_engine/standards_engine/mcp.py index 5280fca6..0a74a5f8 100644 --- a/tools/standards_engine/standards_engine/mcp.py +++ b/tools/standards_engine/standards_engine/mcp.py @@ -10,6 +10,7 @@ from contextlib import redirect_stdout from copy import deepcopy import json +import os from pathlib import Path import sys import traceback @@ -22,7 +23,7 @@ from .context_projection import Purpose from .mcp_catalog import OutputSchemaDelivery, tool_catalog from .interaction_observer import ( - DEFAULT_MAX_AGE_SECONDS, DEFAULT_MAX_BYTES, DEFAULT_MAX_CALLS, + DEFAULT_DEPLOYMENT, DEFAULT_MAX_AGE_SECONDS, DEFAULT_MAX_BYTES, DEFAULT_MAX_CALLS, InteractionRecorder, RecorderConfig, serialized_bytes, ) @@ -297,16 +298,19 @@ def main() -> int: help="Advertise complete output schemas (eager, default), or retrieve exact contracts through describe_output (on-demand).", ) parser.add_argument('--observe-database', type=Path, - help='Opt in to operator-only local SQLite observations in a trusted directory.') - parser.add_argument('--observe-deployment', help='Required nonsensitive deployment label when recording.') + help='Record operator-only observations in this SQLite file instead of the default location; its directory must exist.') + parser.add_argument('--observe-deployment', default=DEFAULT_DEPLOYMENT, + help='Nonsensitive deployment label stored with each recorded session.') + parser.add_argument('--no-observe', action='store_true', + help='Do not record this process. STANDARDS_ENGINE_OBSERVE=off does the same.') parser.add_argument('--observe-max-calls', type=int, default=DEFAULT_MAX_CALLS) parser.add_argument('--observe-max-age-seconds', type=int, default=DEFAULT_MAX_AGE_SECONDS) parser.add_argument('--observe-max-bytes', type=int, default=DEFAULT_MAX_BYTES) arguments = parser.parse_args() - if (arguments.observe_database is None) != (arguments.observe_deployment is None): - parser.error('--observe-database and --observe-deployment must be supplied together') + # Recording is on for every server process. Only these two switches turn it + # off; in-process MCPServer construction records only when given a configuration. observation = None - if arguments.observe_database is not None: + if not arguments.no_observe and os.environ.get('STANDARDS_ENGINE_OBSERVE', '').strip().lower() != 'off': try: observation = RecorderConfig(arguments.observe_database, arguments.observe_deployment, arguments.observe_max_calls, arguments.observe_max_age_seconds, diff --git a/tools/standards_engine/tests/agent_efficiency_trace.py b/tools/standards_engine/tests/agent_efficiency_trace.py index 82135c23..7711b255 100644 --- a/tools/standards_engine/tests/agent_efficiency_trace.py +++ b/tools/standards_engine/tests/agent_efficiency_trace.py @@ -49,7 +49,7 @@ def call(self, name: str, arguments: dict, *, rejected: bool = False) -> dict: ] response = subprocess.run( [sys.executable, "-P", "-m", "tools.standards_engine.standards_engine.mcp", - "--repo-root", str(self.root), "--purpose", self.purpose], + "--repo-root", str(self.root), "--purpose", self.purpose, "--no-observe"], input="".join(json.dumps(item) + "\n" for item in messages), text=True, capture_output=True, check=True, env=os.environ.copy(), ) diff --git a/tools/standards_engine/tests/codex_discovery_client.py b/tools/standards_engine/tests/codex_discovery_client.py index 770bcdfa..d036d884 100644 --- a/tools/standards_engine/tests/codex_discovery_client.py +++ b/tools/standards_engine/tests/codex_discovery_client.py @@ -422,7 +422,7 @@ async def run(arguments) -> dict: # Run-owned fixture coordinates take precedence over operator surface choices. command.extend(['-c', 'analytics.enabled=false', '-c', f'mcp_servers.{server}.command={json.dumps(sys.executable)}', - '-c', f'mcp_servers.{server}.args={json.dumps(["-P", "-m", "tools.standards_engine.standards_engine.mcp", "--repo-root", str(fixture), "--purpose", "authoring", "--output-schemas", arguments.output_schemas])}', + '-c', f'mcp_servers.{server}.args={json.dumps(["-P", "-m", "tools.standards_engine.standards_engine.mcp", "--repo-root", str(fixture), "--purpose", "authoring", "--output-schemas", arguments.output_schemas, "--no-observe"])}', '-c', f'mcp_servers.{server}.env.PYTHONPATH={json.dumps(str(ROOT))}']) events = [] report = {'observer_version': OBSERVER_VERSION, 'status': 'unavailable', 'client_version': version, 'requested_model': arguments.model, diff --git a/tools/standards_engine/tests/codex_navigation_client.py b/tools/standards_engine/tests/codex_navigation_client.py index ab4419d8..db153307 100644 --- a/tools/standards_engine/tests/codex_navigation_client.py +++ b/tools/standards_engine/tests/codex_navigation_client.py @@ -26,6 +26,10 @@ async def main(server_name, output_schemas="eager"): "--stdio", "-c", "analytics.enabled=false", + # A scripted check is not agent behaviour: keep it out of the + # configured server's always-on interaction recording. + "-c", + f'mcp_servers.{server_name}.env.STANDARDS_ENGINE_OBSERVE="off"', stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=log, diff --git a/tools/standards_engine/tests/mcp_policy_registration_client.py b/tools/standards_engine/tests/mcp_policy_registration_client.py index 89d18e7d..4002c155 100644 --- a/tools/standards_engine/tests/mcp_policy_registration_client.py +++ b/tools/standards_engine/tests/mcp_policy_registration_client.py @@ -66,7 +66,7 @@ def parameters(purpose="authoring"): return StdioServerParameters( command=engine_python, args=["-P", "-m", "tools.standards_engine.standards_engine.mcp", - "--purpose", purpose, "--repo-root", str(repo)], + "--purpose", purpose, "--repo-root", str(repo), "--no-observe"], env={**os.environ, "PYTHONPATH": str(ROOT)}, ) diff --git a/tools/standards_engine/tests/mcp_workflow_client.py b/tools/standards_engine/tests/mcp_workflow_client.py index c55530a8..d64bf2a0 100644 --- a/tools/standards_engine/tests/mcp_workflow_client.py +++ b/tools/standards_engine/tests/mcp_workflow_client.py @@ -51,7 +51,7 @@ def parameters(interrupted=False, *, purpose="authoring"): ) return StdioServerParameters( command=engine_python, - args=["-P", *launch, "--purpose", purpose, "--repo-root", str(repo)], + args=["-P", *launch, "--purpose", purpose, "--repo-root", str(repo), "--no-observe"], env={**os.environ, "PYTHONPATH": str(ROOT)}, ) diff --git a/tools/standards_engine/tests/test_agent_interaction_transport.py b/tools/standards_engine/tests/test_agent_interaction_transport.py index 03970523..a7a42d36 100644 --- a/tools/standards_engine/tests/test_agent_interaction_transport.py +++ b/tools/standards_engine/tests/test_agent_interaction_transport.py @@ -38,7 +38,7 @@ def call(self, purpose, operation, arguments, *, rejected=False, delivery="eager process = subprocess.run( [sys.executable, '-P', '-m', 'tools.standards_engine.standards_engine.mcp', '--repo-root', str(self.root), '--purpose', purpose, - '--output-schemas', delivery], + '--output-schemas', delivery, '--no-observe'], env={**os.environ, 'PYTHONPATH': str(fixture.ROOT)}, text=True, input=''.join(json.dumps(value) + '\n' for value in messages), capture_output=True, timeout=90, diff --git a/tools/standards_engine/tests/test_consumer_publication.py b/tools/standards_engine/tests/test_consumer_publication.py index b5d05cc0..4d01fa31 100644 --- a/tools/standards_engine/tests/test_consumer_publication.py +++ b/tools/standards_engine/tests/test_consumer_publication.py @@ -46,7 +46,7 @@ def rpc(self, method, params, purpose='authoring'): ] process=subprocess.run( [sys.executable,'-P','-m','tools.standards_engine.standards_engine.mcp', - '--repo-root',str(self.root),'--purpose',purpose,'--advanced'], + '--repo-root',str(self.root),'--purpose',purpose,'--advanced','--no-observe'], input=''.join(json.dumps(m)+'\n' for m in messages),text=True,capture_output=True, env={**os.environ,'PYTHONPATH':str(ROOT)},timeout=180, ) diff --git a/tools/standards_engine/tests/test_coverage_publication.py b/tools/standards_engine/tests/test_coverage_publication.py index bd2ddeba..799682b4 100644 --- a/tools/standards_engine/tests/test_coverage_publication.py +++ b/tools/standards_engine/tests/test_coverage_publication.py @@ -610,6 +610,7 @@ def test_review_verify_apply_recover_and_read_without_original_database(self): str(repository), "--purpose", "authoring", + "--no-observe", ], input="".join(json.dumps(message) + "\n" for message in messages), text=True, diff --git a/tools/standards_engine/tests/test_discovered_workflow.py b/tools/standards_engine/tests/test_discovered_workflow.py index 78503e1a..da1691f7 100644 --- a/tools/standards_engine/tests/test_discovered_workflow.py +++ b/tools/standards_engine/tests/test_discovered_workflow.py @@ -52,7 +52,7 @@ def call(operation, arguments): {'jsonrpc': '2.0', 'method': 'notifications/initialized'}, selected] process = subprocess.run([sys.executable, '-m', 'tools.standards_engine.standards_engine.mcp', '--repo-root', str(self.root), - '--purpose', 'authoring', '--output-schemas', delivery], + '--purpose', 'authoring', '--output-schemas', delivery, '--no-observe'], input=''.join(json.dumps(message) + '\n' for message in messages), text=True, capture_output=True, check=True) self.assertEqual(process.stderr, '') diff --git a/tools/standards_engine/tests/test_immutable_work_reuse.py b/tools/standards_engine/tests/test_immutable_work_reuse.py index e8caaf76..aeb93f09 100644 --- a/tools/standards_engine/tests/test_immutable_work_reuse.py +++ b/tools/standards_engine/tests/test_immutable_work_reuse.py @@ -389,7 +389,7 @@ def test_stdio_cold_restarts_and_warm_calls_preserve_results(self): results=[] for _ in range(2): process=subprocess.run( - [sys.executable,'-P','-m','tools.standards_engine.standards_engine.mcp','--repo-root',str(self.root),'--purpose','authoring','--output-schemas','on-demand'], + [sys.executable,'-P','-m','tools.standards_engine.standards_engine.mcp','--repo-root',str(self.root),'--purpose','authoring','--output-schemas','on-demand','--no-observe'], input=''.join(json.dumps(item)+'\n' for item in messages),text=True,capture_output=True,check=True, env={**os.environ,'PYTHONPATH':str(ROOT)},cwd=self.temporary.name, ) diff --git a/tools/standards_engine/tests/test_input_discovery.py b/tools/standards_engine/tests/test_input_discovery.py index 312de9a5..1810b75c 100644 --- a/tools/standards_engine/tests/test_input_discovery.py +++ b/tools/standards_engine/tests/test_input_discovery.py @@ -283,7 +283,7 @@ def cold(arguments): messages = [request('initialize', {'protocolVersion': '2025-11-25', 'capabilities': {}, 'clientInfo': {'name': 'discovery-fixture', 'version': '1'}}), {'jsonrpc': '2.0', 'method': 'notifications/initialized'}, request('tools/call', {'name': 'describe_input', 'arguments': arguments}, identifier=2)] - process = subprocess.run([sys.executable, '-P', '-m', 'tools.standards_engine.standards_engine.mcp', '--repo-root', str(root), '--purpose', 'authoring', '--advanced'], + process = subprocess.run([sys.executable, '-P', '-m', 'tools.standards_engine.standards_engine.mcp', '--repo-root', str(root), '--purpose', 'authoring', '--advanced', '--no-observe'], input=''.join(json.dumps(m)+'\n' for m in messages), capture_output=True, text=True, env=environment, timeout=60) self.assertEqual(process.returncode, 0, process.stderr) self.assertEqual(process.stderr, '') diff --git a/tools/standards_engine/tests/test_interaction_observer.py b/tools/standards_engine/tests/test_interaction_observer.py index 01aa31b5..90b77b79 100644 --- a/tools/standards_engine/tests/test_interaction_observer.py +++ b/tools/standards_engine/tests/test_interaction_observer.py @@ -1,4 +1,8 @@ -"""Synthetic operator evidence; never records a real agent/model session.""" +"""Synthetic operator evidence; never records a real agent/model session. + +Every recorder here writes to a temporary directory. Child processes get a +temporary HOME so the always-on default can never reach a developer's database. +""" from __future__ import annotations from contextlib import redirect_stderr @@ -6,17 +10,20 @@ import json import os from pathlib import Path +import re import sqlite3 +import stat import subprocess import sys import tempfile +import threading import time import unittest from unittest.mock import patch from tools.standards_engine.standards_engine.interaction_observer import ( - APPLICATION_ID, InputShape, InteractionRecorder, RecorderConfig, SCHEMA_VERSION, - report, + APPLICATION_ID, DEFAULT_DATABASE_NAME, InputShape, InteractionRecorder, RecorderConfig, + SCHEMA_VERSION, StorageRejected, TRUNCATED, default_database, report, text_report, ) from tools.standards_engine.standards_engine.mcp import MCPServer, serve from tools.standards_engine.standards_engine.tools import AgentToolFacade @@ -24,6 +31,52 @@ MODULE = 'tools.standards_engine.standards_engine.interaction_observer' MCP_MODULE = 'tools.standards_engine.standards_engine.mcp' +SNAPSHOT = {'kind': 'snapshot-handle', 'id': 'snapshot:v1:5e17e1a1-0000-4000-8000-000000000001', 'schema_version': 5} +ANALYSIS = {'kind': 'analysis-handle', 'id': 'analysis:sha256:' + 'ab' * 32, 'schema_version': 7} +# The request metadata Codex attaches to every tool call, with synthetic values. +CODEX_META = { + 'callId': 'exec-SENTINEL_CALL', 'threadId': 'SENTINEL_THREAD', 'sessionId': 'SENTINEL_SESSION', 'progressToken': 9, + 'x-codex-turn-metadata': { + 'session_id': 'SENTINEL_SESSION', 'thread_id': 'SENTINEL_THREAD', 'turn_id': 'SENTINEL_TURN', + 'model': 'SENTINEL_MODEL', 'thread_source': 'subagent', + 'workspaces': {'/SENTINEL/WORKSPACE': {'associated_remote_urls': {'origin': 'git@example.invalid:SENTINEL/REPO.git'}}}}, +} +V1_DDL = ( + 'CREATE TABLE sessions (id TEXT PRIMARY KEY, started REAL NOT NULL, runtime TEXT NOT NULL, deployment TEXT NOT NULL, catalog TEXT NOT NULL, pruned INTEGER NOT NULL DEFAULT 0)', + 'CREATE TABLE interactions (id TEXT PRIMARY KEY, session TEXT NOT NULL REFERENCES sessions(id), ordinal INTEGER NOT NULL, started REAL NOT NULL, method TEXT NOT NULL, operation TEXT NOT NULL, input_shape TEXT NOT NULL, shape_digest TEXT NOT NULL, discovery_operation TEXT, catalog_state TEXT NOT NULL, request_bytes INTEGER, scope TEXT NOT NULL, UNIQUE(session, ordinal))', + "CREATE TABLE events (interaction TEXT PRIMARY KEY REFERENCES interactions(id) ON DELETE CASCADE, phase TEXT NOT NULL CHECK(phase IN ('end','error','incomplete')), finished REAL NOT NULL, duration_ms REAL NOT NULL, response_bytes INTEGER, outcome TEXT NOT NULL, feedback TEXT NOT NULL)", + 'CREATE INDEX interaction_age ON interactions(started)', +) + + +def environment(home: Path, **extra: str) -> dict: + """A child environment whose default observation location is under `home`.""" + env = {name: value for name, value in os.environ.items() + if name not in ('XDG_DATA_HOME', 'STANDARDS_ENGINE_OBSERVE')} + return {**env, 'PYTHONPATH': str(ROOT), 'HOME': str(home), **extra} + + +def rejection(code, pointer=None, keyword='fact', **extra): + value = {'kind': 'rejected-result', 'code': code, 'outcome': 'invalid', 'message': 'SENTINEL_MESSAGE', + 'details': {'SENTINEL_DETAIL': 'SENTINEL_DETAIL'}, 'next_operations': [], **extra} + if pointer is not None: + value['input_feedback'] = {'issues': [{'instance_pointer': pointer, 'keyword': keyword, + 'message': 'SENTINEL_MESSAGE'}], 'truncated': False} + return value + + +def route_result(unresolved=('routing.topics',)): + return {'kind': 'compact-route-result', 'status': 'needs-facts' if unresolved else 'complete', 'snapshot': SNAPSHOT, + 'summary': 'SENTINEL_SUMMARY', + 'reading_plan': [{'target': 'core', 'state': 'selected'}, {'target': 'router', 'state': 'selected'}, + {'target': 'topic.security', 'state': 'conditional'}], + 'unresolved_questions': [{'fact': {'id': name, 'prompt': 'SENTINEL_PROMPT'}} for name in unresolved], + 'content': {'offset': 0, 'total': 2, 'items': [read_result('core')]}} + + +def read_result(target): + return {'kind': 'compact-read-result', 'snapshot': SNAPSHOT, 'content': 'SENTINEL_STANDARD_TEXT', + 'policy': {'handle': {'kind': 'snapshot-child-handle', 'child_kind': 'policy', 'child_id': target}}} class ObserverTests(unittest.TestCase): @@ -33,9 +86,9 @@ def setUp(self): self.database = Path(self.temporary.name) / 'observations.sqlite' self.diagnostics = io.StringIO() - def server(self, **options): + def server(self, *, advanced=False, **options): with redirect_stderr(self.diagnostics): - server = MCPServer(ROOT, purpose='authoring', + server = MCPServer(ROOT, purpose='authoring', advanced=advanced, observation=RecorderConfig(self.database, 'synthetic', **options)) self.addCleanup(server.close) return server @@ -45,15 +98,23 @@ def rows(self, sql): db.row_factory = sqlite3.Row return [dict(row) for row in db.execute(sql)] - def test_opt_in_does_not_change_catalog_or_results(self): + def call(self, server, name, arguments, value, meta=None): + """One tool call whose Engine result is `value`; no store is opened.""" + params = {'name': name, 'arguments': arguments, **({'_meta': meta} if meta else {})} + with patch.object(server, '_request', return_value=server._tool_result(value)): + return server.dispatch(request('tools/call', params)) + + def stored_bytes(self): + return b''.join(path.read_bytes() for path in self.database.parent.iterdir()) + + def test_recording_does_not_change_catalog_instructions_or_results(self): plain = MCPServer(ROOT, purpose='authoring') self.addCleanup(plain.close) observed = self.server() self.assertEqual(plain.tools, observed.tools) - for server in (plain, observed): - initialize(server) # A fixed process identity makes these full public responses comparable. observed._runtime_identity._instance = plain._runtime_identity._instance + self.assertEqual(initialize(plain), initialize(observed)) for message in (request('tools/list'), request('tools/call', {'name': 'runtime_info'}), request('tools/call', {'name': 'describe_input', 'arguments': {'operation': 'apply'}}), request('tools/call', {'name': 'runtime_info', 'arguments': {'secret': 'private'}}), @@ -68,6 +129,7 @@ def test_opt_in_does_not_change_catalog_or_results(self): self.assertEqual(result['sessions'][0]['runtime']['catalog_digest'], plain._runtime_identity.metadata()['catalog_digest']) self.assertNotIn('observer', json.dumps(observed.tools)) + self.assertEqual(self.diagnostics.getvalue(), '', 'a healthy recorder is silent') def test_shape_and_feedback_disclose_no_values_or_dynamic_keys(self): schema = {'type': 'object', 'properties': { @@ -85,18 +147,165 @@ def test_shape_and_feedback_disclose_no_values_or_dynamic_keys(self): self.assertNotIn(secret, encoded) self.assertEqual(shape.project(value)['fields']['body'], 'redacted') self.assertEqual(shape.project(value)['fields']['facts']['fields'], {}) - feedback = shape.feedback({'issues': [ + issues = {'issues': [ {'instance_pointer': '/facts/facts/body', 'keyword': 'type', 'message': 'CREDENTIAL'}, {'instance_pointer': '/items/8/selector', 'keyword': 'required'}, {'instance_pointer': '/body/token', 'keyword': 'CREDENTIAL'}, - ]}) - self.assertEqual(feedback, [{'pointer': '/facts/*/*', 'keyword': 'type'}, - {'pointer': '/items/*/selector', 'keyword': 'required'}, - {'pointer': '/body/*', 'keyword': 'other'}]) + {'instance_pointer': '/facts/routing.topics', 'keyword': 'fact'}, + {'instance_pointer': '/items/routing.topics', 'keyword': 'evidence_ref'}, + ]} + self.assertEqual(shape.feedback(issues), [ + {'pointer': '/facts/*/*', 'keyword': 'type'}, {'pointer': '/items/*/selector', 'keyword': 'required'}, + {'pointer': '/body/*', 'keyword': 'other'}, {'pointer': '/facts/*', 'keyword': 'fact'}, + {'pointer': '/items/*', 'keyword': 'evidence_ref'}]) + # A fact name the same call already recorded may locate its own rejection; + # the same text under any other map stays a wildcard. + named = shape.feedback(issues, frozenset({'routing.topics'})) + self.assertEqual([issue['pointer'] for issue in named][3:], ['/facts/routing.topics', '/items/*']) # Deep/large adversarial data is bounded without traversing unknown maps. projected = shape.project({'items': [{'selector': 'x' * 1_000_000}] * 100_000}) self.assertLess(len(json.dumps(projected)), 8192) + def test_navigation_values_results_sizes_and_task_identity_are_recorded(self): + server = self.server() + initialize(server) + facts = {'routing.activities': ['implementation', 'testing'], 'python': True, 'task': 'p' * 300} + items = [{'target': 'core'}, {'target': 'router', 'detail': 'full', 'include_routing': True, 'extra': 'DROPPED'}] + calls = ( + ('route', {'facts': facts, 'content': {'limit': 1}, 'detail': 'compact'}, route_result()), + ('read', {'snapshot': SNAPSHOT, 'target': 'core', 'detail': 'full', 'handle': {'kind': 'DROPPED'}, + 'request': {'kind': 'route', 'facts': {'DROPPED': 'DROPPED'}}, 'facts': {'DROPPED': True}}, + read_result('core')), + ('read_many', {'snapshot': SNAPSHOT, 'items': items}, + {'kind': 'read-many-result', 'snapshot': SNAPSHOT, 'items': [read_result('core'), read_result('router')]}), + ('related', {'snapshot': SNAPSHOT, 'target': 'core', 'groups': ['semantic'], 'direction': 'both', 'transitive': False}, + rejection('GRAPH.UNKNOWN_GROUP')), + ('query_proposal', {'revision': {'kind': 'proposal-revision-handle', 'id': 'proposal-revision:sha256:' + 'cd' * 32}, + 'request': {'kind': 'route', 'facts': {'nested.fact': {'type': 'string', 'state': 'known', 'value': 'nested-value'}}}}, + rejection('AGGREGATE.UNAVAILABLE')), + ) + for name, arguments, value in calls: + self.call(server, name, arguments, value, CODEX_META) + server.dispatch(request('tools/call', {'name': 'describe_input', 'arguments': { + 'operation': 'route', 'selector': 'RouteCall', 'limit': 2, 'expected_catalog': 'sha256:' + '0' * 64}})) + recorded = {row['operation']: row for row in self.rows( + 'SELECT i.*,e.outcome,e.result,e.result_bytes FROM interactions i JOIN events e ON e.interaction=i.id ' + "WHERE i.method='tools/call'")} + values = {name: json.loads(row['arguments']) for name, row in recorded.items()} + results = {name: json.loads(row['result']) for name, row in recorded.items()} + self.assertEqual(values['route'], {'detail': 'compact', 'content': {'limit': 1}, 'facts': { + 'routing.activities': ['implementation', 'testing'], 'python': True, 'task': 'p' * 200 + TRUNCATED}}) + self.assertEqual(results['route'], { + 'kind': 'compact-route-result', 'status': 'needs-facts', 'selected': ['core', 'router'], + 'unresolved': ['routing.topics'], 'content': {'offset': 0, 'total': 2, 'items': 1, 'targets': ['core']}}) + self.assertEqual(recorded['route']['outcome'], 'needs-facts') + reused = values['read']['snapshot'] + self.assertRegex(reused, '^[0-9a-f]{12}$') + self.assertEqual(values['read'], {'snapshot': reused, 'target': 'core', 'detail': 'full'}) + self.assertEqual(values['read_many'], {'snapshot': reused, 'items': [ + {'target': 'core'}, {'target': 'router', 'detail': 'full', 'include_routing': True}]}) + self.assertEqual(results['read_many'], {'kind': 'read-many-result', 'targets': ['core', 'router']}) + self.assertEqual(values['related'], {'snapshot': reused, 'target': 'core', 'groups': ['semantic'], + 'direction': 'both', 'transitive': False}) + self.assertEqual(results['related'], {'kind': 'rejected-result', 'code': 'GRAPH.UNKNOWN_GROUP', 'outcome': 'invalid'}) + self.assertEqual(values['query_proposal'], {'revision': {'kind': 'proposal-revision-handle'}, 'request': { + 'kind': 'route', 'facts': {'nested.fact': {'type': 'string', 'state': 'known', 'value': 'nested-value'}}}}) + self.assertEqual(values['describe_input'], {'operation': 'route', 'selector': 'RouteCall', 'limit': 2}) + self.assertEqual(recorded['describe_input']['catalog_state'], 'differs') + # Sizes: the arguments object alone and one serialization of structuredContent. + self.assertEqual(recorded['read']['arguments_bytes'], len(json.dumps(calls[1][1], separators=(',', ':')))) + self.assertEqual(recorded['read']['result_bytes'], len(json.dumps(read_result('core')))) + self.assertGreater(recorded['read']['request_bytes'], recorded['read']['arguments_bytes']) + # Task identity: one salted hash per client thread, never the id itself. + threads = {(row['thread'], row['origin']) for name, row in recorded.items() if name != 'describe_input'} + self.assertEqual(len(threads), 1) + thread, origin = threads.pop() + self.assertRegex(thread, '^[0-9a-f]{16}$') + self.assertEqual(origin, 'subagent') + self.assertEqual((recorded['describe_input']['thread'], recorded['describe_input']['origin']), (None, 'unknown')) + self.assertEqual(self.rows('SELECT client_name,client_version FROM sessions'), + [{'client_name': 'test', 'client_version': '1'}]) + stored = self.stored_bytes() + for private in (b'SENTINEL', b'5e17e1a1', b'cdcdcdcd', b'DROPPED'): + self.assertNotIn(private, stored) + # The salt belongs to the database: another process maps the thread to the same hash. + second = self.server() + self.call(second, 'read', {'target': 'core'}, read_result('core'), CODEX_META) + self.assertEqual({row['thread'] for row in self.rows('SELECT thread FROM interactions WHERE thread IS NOT NULL')}, {thread}) + + def test_authoring_prose_never_reaches_disk_while_route_facts_do(self): + server = self.server(advanced=True) + initialize(server) + prose = {name: f'SENTINEL_{name.upper()}' for name in ( + 'body', 'title', 'summary', 'rationale', 'intent', 'heading', 'condition', 'path', 'label', + 'evidence', 'applies', 'verification', 'description', 'provenance', 'value', 'tool')} + evidence = {'id': prose['evidence'], 'digest': 'sha256:' + 'ef' * 32, 'provider_contract': 'review-evidence', + 'provider_contract_version': '1'} + change_set = {'purpose': {'summary': prose['summary'], 'rationale': prose['rationale'], 'evidence': [{'evidence_ref': prose['label']}]}, 'edits': [ + {'kind': 'revise-policy-unit', 'policy': 'workflow.planning.written-plan-applicability', 'title': prose['title'], 'body': prose['body'], + 'semantics': {'kind': 'change', 'accepted_semantic_revision': 1, 'proposed_semantic_revision': 2, 'intent': prose['intent']}}, + {'kind': 'create-standard', 'requires': ['core'], 'specializes': [], 'standard': { + 'id': 'topic.recorded-identifier', 'title': prose['title'], 'body': prose['body'], 'level': 'SHOULD', 'role': 'topic', + 'applies_when': prose['applies'], 'does_not_apply_when': prose['applies'], 'verification': prose['verification']}, + 'policy_units': [{'id': 'topic.recorded-identifier.unit', 'heading_chain': [prose['heading']], 'intent': prose['intent'], + 'semantic_revision': 1, 'aliases': [], 'predecessors': [], 'successors': []}]}, + {'kind': 'put-policy-relationship', 'relationship': { + 'source_policy': 'core.application-guidance', 'consumer': 'prompts/planning.md', 'relation': 'prompt-projection', + 'evidence_owner': 'review:consumer', 'rationale': prose['rationale'], 'applicability': {'operator': 'always'}}}, + {'kind': 'register-consumer', 'consumer': 'consumer.recorded', 'artifact_kind': 'documentation', 'authority': 'projection', + 'path': prose['path']}, + {'kind': 'put-routing-rule', 'rationale': prose['rationale'], 'rule': { + 'id': 'rule.recorded', 'target': 'topic.security', 'condition': prose['condition'], + 'when': {'operator': 'equals', 'fact': 'routing.topics', 'value': prose['value']}}}, + # Prose placed in an identifier field is dropped by its shape. + {'kind': 'audit-policy-unit', 'policy': 'SENTINEL PROSE in an identifier field', 'rationale': prose['rationale']}, + ]} + child = {'kind': 'analysis-child-handle', 'analysis': ANALYSIS, 'child_kind': 'obligation', 'child_id': 'sha256:' + '12' * 32} + calls = ( + ('propose', {'snapshot': SNAPSHOT, 'detail': 'full', 'change_set': change_set, 'evidence': {prose['label']: evidence}}), + ('revise', {'context': ANALYSIS, 'change_set': change_set}), + ('review', {'context': ANALYSIS, 'decisions': [ + {'owner': 'consumer', 'decision': 'accept', 'rationale': prose['rationale'], 'evidence': [evidence]}]}), + ('resolve_workflow', {'context': ANALYSIS, 'submission': { + 'kind': 'coverage-attestation', 'claim': {'requirement': child, 'conclusion': 'complete', 'rationale': prose['rationale'], + 'auditor_provenance': prose['provenance'], 'evidence': [evidence], + 'explicit_exclusions': [evidence]}}}), + ('recover', {'context': ANALYSIS, 'action': 'observe'}), + ('maintain_evidence', {'kind': 'maintain-evidence', 'expected_revision': prose['value'], 'apply': False, 'evidence': [evidence], + 'plan': {'suite_descriptions': [{'suite': prose['label'], 'description': prose['description']}], + 'replacement_evidence_rationale': prose['rationale'], + 'consumer_registrations': [{'path': prose['path'], 'rationale': prose['rationale'], + 'artifact_kind': 'fixture', 'relation': 'fixture-projection'}]}}), + ) + for name, arguments in calls: + self.call(server, name, arguments, rejection('INTERFACE.INVALID_ARGUMENTS', '/change_set/purpose/' + prose['label'], 'minItems'), + CODEX_META) + server.dispatch(request('tools/call', {'name': prose['tool'], 'arguments': {'body': prose['body']}}, identifier=prose['value'])) + # Route facts are kept as sent, in the focused form and inside a preview request. + self.call(server, 'route', {'facts': {'OOV_NAME_python': True, 'task': 'OOV free text about a parser', + 'routing.activities': ['implementation', 'OOV_VALUE_testing']}}, + rejection('ROUTE.INPUT_INVALID', '/facts')) + self.call(server, 'preview_application', {'revision': {'kind': 'proposal-revision-handle', 'id': 'proposal-revision:sha256:' + '34' * 32}, + 'request': {'kind': 'route', 'facts': {'OOV_NESTED': {'type': 'string', 'state': 'known', 'value': 'OOV_NESTED_VALUE'}}}}, + rejection('ROUTE.INPUT_INVALID', '/request/facts')) + for closed in (False, True): + stored = self.stored_bytes() # The main file, and the write-ahead log while it exists. + for private in (b'SENTINEL', b'abababab', b'efefefef', b'12121212', b'34343434', b'5e17e1a1'): + self.assertNotIn(private, stored, (private, closed)) + for kept in (b'OOV_NAME_python', b'OOV free text about a parser', b'OOV_VALUE_testing', b'OOV_NESTED_VALUE', + b'workflow.planning.written-plan-applicability', b'topic.recorded-identifier.unit', + b'prompts/planning.md', b'consumer.recorded', b'revise-policy-unit', b'analysis-handle', + b'INTERFACE.INVALID_ARGUMENTS'): + self.assertIn(kept, stored, (kept, closed)) + server.close() + summary = report(self.database) + self.assertNotIn('SENTINEL', json.dumps(summary) + text_report(summary)) + propose = json.loads(self.rows("SELECT arguments FROM interactions WHERE operation='propose'")[0]['arguments']) + self.assertEqual(propose['change_set']['edits'][0], { + 'kind': 'revise-policy-unit', 'policy': 'workflow.planning.written-plan-applicability', 'semantics': {'kind': 'change'}}) + self.assertEqual(propose['change_set']['edits'][5], {'kind': 'audit-policy-unit'}) + self.assertEqual((propose['snapshot'], propose['detail']), ({'kind': 'snapshot-handle'}, 'full')) + def test_privacy_at_real_dispatch_and_disk_boundary(self): server = self.server() initialize(server) @@ -104,7 +313,8 @@ def test_privacy_at_real_dispatch_and_disk_boundary(self): server.dispatch(request('tools/call', {'name': 'runtime_info', 'arguments': { 'expected_catalog': secrets[0], secrets[1]: secrets[2]}}, identifier=secrets[0])) server.dispatch(request('tools/call', {'name': secrets[1], 'arguments': {'body': secrets[2]}})) - server.dispatch(request('initialize', {'clientInfo': {'name': secrets[0]}})) + # Only the first initialize names the client; other clientInfo members are never read. + server.dispatch(request('initialize', {'clientInfo': {'name': secrets[0], 'title': secrets[1]}})) server.close() for path in self.database.parent.iterdir(): contents = path.read_bytes() @@ -120,13 +330,17 @@ def test_privacy_at_real_dispatch_and_disk_boundary(self): def test_malformed_envelopes_and_parse_errors_do_not_disable_recorder(self): server = self.server() for value in (None, [], {}, {'method': 'ping'}, {'id': 1, 'method': [], 'jsonrpc': '2.0'}, - request('tools/call', {'name': []}), request('ping', [])): + request('tools/call', {'name': []}), request('ping', []), + request('tools/call', {'name': 'route', 'arguments': [], '_meta': []}), + request('tools/call', {'name': 'read_many', 'arguments': {'items': 'x', 'snapshot': []}, + '_meta': {'x-codex-turn-metadata': {'thread_id': [], 'thread_source': {}}}})): server.dispatch(value) output = io.StringIO() serve(server, io.StringIO('{BAD JSON\n'), output) self.assertEqual(json.loads(output.getvalue())['error']['code'], -32700) self.assertEqual(server._observer.health['state'], 'healthy') - self.assertEqual(report(self.database)['retained_starts'], 8) + self.assertEqual(server._observer.health['lost'], 0) + self.assertEqual(report(self.database)['retained_starts'], 10) self.assertIn('parse-error', {row['outcome'] for row in self.rows('SELECT outcome FROM events')}) def test_tool_exception_interruption_and_delivery_failure(self): @@ -146,33 +360,89 @@ def broken(response): events = self.rows('SELECT phase,outcome,response_bytes FROM events') self.assertEqual([r['outcome'] for r in events], ['response', 'tool-exception', 'unknown', 'unknown']) self.assertEqual(sum(r['phase'] == 'incomplete' for r in events), 2) - self.assertNotIn('SENSITIVE_', self.database.read_bytes().decode(errors='ignore')) + self.assertNotIn(b'SENSITIVE_', self.stored_bytes()) - def test_unavailable_locked_and_failed_health_sink_preserve_responses(self): - unavailable = Path(self.temporary.name) / 'missing' / 'db' - with redirect_stderr(io.StringIO()): - server = MCPServer(ROOT, purpose='authoring', observation=RecorderConfig(unavailable, 'synthetic')) - self.addCleanup(server.close) - self.assertEqual(server.dispatch(request('ping'))['result'], {}) - self.assertEqual(server._observer.health['state'], 'degraded') + def test_locked_database_delays_rows_but_never_drops_or_slows_a_call(self): observed = self.server() with sqlite3.connect(self.database, isolation_level=None) as lock: lock.execute('BEGIN IMMEDIATE') before = time.monotonic() - response = observed.dispatch(request('ping')) + responses = [observed.dispatch(request('ping')) for _ in range(3)] elapsed = time.monotonic() - before + self.assertEqual(report(self.database)['retained_starts'], 0) lock.execute('ROLLBACK') - self.assertEqual(response['result'], {}) - self.assertEqual(observed._observer.health['reason'], 'storage-locked') - self.assertLess(elapsed, 1, '20ms SQLite busy policy must not wait indefinitely') + self.assertEqual([response['result'] for response in responses], [{}, {}, {}]) + self.assertLess(elapsed, 1, 'six lock waits of 20 ms must not delay three calls materially') + health = observed._observer.health + self.assertEqual((health['state'], health['reason'], health['backlog']), ('degraded', 'storage-locked', 6)) + # The next call delivers the whole backlog in order. + observed.dispatch(request('ping')) + self.assertEqual((health['state'], health['backlog'], health['lost']), ('healthy', 0, 0)) + self.assertEqual((health['recorded_starts'], health['recorded_terminals']), (4, 4)) + self.assertEqual([row['ordinal'] for row in self.rows('SELECT ordinal FROM interactions ORDER BY started')], [1, 2, 3, 4]) + # Orderly close waits longer for a writer than a call may. + lock = sqlite3.connect(self.database, isolation_level=None, check_same_thread=False) + lock.execute('BEGIN IMMEDIATE') + observed.dispatch(request('ping')) + self.assertEqual(health['backlog'], 2) + release = threading.Timer(0.3, lambda: (lock.execute('ROLLBACK'), lock.close())) + release.start() + observed.close() + release.join() + summary = report(self.database) + self.assertEqual((summary['retained_starts'], summary['retained_terminals'], summary['lost_rows']), (5, 5, 0)) + notes = [json.loads(line.split(' ', 2)[2]) for line in self.diagnostics.getvalue().splitlines()] + # One line per change of health, then the totals at close; nothing while healthy. + self.assertEqual([(note['state'], note['reason']) for note in notes], + [('degraded', 'storage-locked'), ('healthy', None), ('degraded', 'storage-locked'), + ('healthy', None), ('healthy', None)]) + self.assertEqual((notes[-1]['recorded_starts'], notes[-1]['recorded_terminals'], notes[-1]['lost']), (5, 5, 0)) + + def test_backlog_overflow_is_counted_and_the_count_is_persisted(self): + observed = self.server() + with patch(MODULE + '.MAX_BACKLOG', 4): + with sqlite3.connect(self.database, isolation_level=None) as lock: + lock.execute('BEGIN IMMEDIATE') + for _ in range(5): + observed.dispatch(request('ping')) + lock.execute('ROLLBACK') + self.assertEqual((observed._observer.health['backlog'], observed._observer.health['lost']), (4, 6)) + observed.dispatch(request('ping')) + # Calls 1-3 overflowed (6 rows); call 4 lost its start to the sixth call and + # so its terminal as well (2 rows). Calls 5 and 6 are complete. + health = observed._observer.health + self.assertEqual((health['state'], health['lost'], health['recorded_starts'], health['recorded_terminals']), + ('healthy', 8, 2, 2)) + summary = report(self.database) + self.assertEqual((summary['retained_starts'], summary['retained_terminals'], summary['lost_rows']), (2, 2, 8)) + self.assertIn('8 rows lost', text_report(summary)) + + def test_unavailable_storage_reconnects_later_and_reports_what_it_never_wrote(self): + unavailable = Path(self.temporary.name) / 'missing' / 'db' + with redirect_stderr(io.StringIO()): + server = MCPServer(ROOT, purpose='authoring', observation=RecorderConfig(unavailable, 'synthetic')) + self.addCleanup(server.close) + self.assertEqual(server.dispatch(request('ping'))['result'], {}) + health = server._observer.health + self.assertEqual((health['state'], health['reason'], health['backlog']), ('degraded', 'storage-unavailable', 2)) + self.assertFalse(unavailable.parent.exists(), 'an operator-supplied directory is never created') + unavailable.parent.mkdir() + self.assertEqual(server.dispatch(request('ping'))['result'], {}) + self.assertEqual((health['state'], health['recorded_starts'], health['recorded_terminals'], health['lost']), + ('healthy', 2, 2, 0)) + # A process that can never write says so on stderr at close, with its count. class BrokenDiagnostics: def write(self, value): raise OSError('private') def flush(self): raise OSError('private') - recorder = InteractionRecorder(RecorderConfig(unavailable, 'synthetic'), {}, [], diagnostics=BrokenDiagnostics()) - recorder.close() - self.assertEqual(recorder.health['state'], 'degraded') + for diagnostics in (self.diagnostics, BrokenDiagnostics()): + recorder = InteractionRecorder(RecorderConfig(Path(self.temporary.name) / 'absent' / 'db', 'synthetic'), + {'instance_id': 'never', 'catalog_digest': 'c'}, [], diagnostics=diagnostics) + recorder.finish(recorder.begin(request('ping'), request_bytes=1, scope='constructed'), {'result': {}}) + recorder.close() + self.assertEqual((recorder.health['state'], recorder.health['lost']), ('degraded', 2)) + self.assertIn('"lost":2', self.diagnostics.getvalue().splitlines()[-1]) def test_full_storage_after_domain_result_never_repeats_work(self): server = self.server() @@ -195,6 +465,25 @@ def domain(method, params): self.assertEqual(calls, ['ping']) self.assertEqual(server._observer.health['reason'], 'storage-full') self.assertEqual(report(self.database)['unmatched_starts'], 1) + # The terminal waited in the backlog; a later call reconnects and delivers it. + server.dispatch(request('ping')) + self.assertEqual(server._observer.health['state'], 'healthy') + self.assertEqual(report(self.database)['unmatched_starts'], 0) + + def test_byte_cap_evicts_the_oldest_calls_instead_of_refusing_new_ones(self): + recorder = self.server(max_bytes=1024 * 1024)._observer + message = request('tools/call', {'name': 'route', 'arguments': { + 'facts': {f'routing.fact-{index}': ['v' * 150] * 2 for index in range(8)}}}) + for _ in range(900): + recorder.finish(recorder.begin(message, request_bytes=1, scope='constructed'), {'result': {}}, response_bytes=1) + health = recorder.health + self.assertEqual((health['state'], health['lost'], health['recorded_starts']), ('healthy', 0, 900)) + self.assertGreater(health['pruned_interactions'], 0) + retained = self.rows('SELECT min(ordinal) AS oldest,max(ordinal) AS newest,count(*) AS count FROM interactions')[0] + self.assertEqual(retained['newest'], 900) + self.assertEqual(retained['count'], 900 - health['pruned_interactions']) + recorder.close() + self.assertLessEqual(self.database.stat().st_size, 1024 * 1024) def test_migration_reopen_unsupported_corrupt_and_spoofed(self): server = self.server() @@ -203,14 +492,17 @@ def test_migration_reopen_unsupported_corrupt_and_spoofed(self): with sqlite3.connect(self.database) as db: self.assertEqual(db.execute('PRAGMA user_version').fetchone()[0], SCHEMA_VERSION) self.assertEqual(db.execute('PRAGMA application_id').fetchone()[0], APPLICATION_ID) + self.assertEqual(db.execute('PRAGMA journal_mode').fetchone()[0], 'wal') + self.assertRegex(db.execute("SELECT value FROM meta WHERE key='salt'").fetchone()[0], '^[0-9a-f]{32}$') again = self.server() again.dispatch(request('ping')) again.close() self.assertEqual(report(self.database)['retained_starts'], 2) - for name, setup in ( - ('future', 'PRAGMA user_version=999'), - ('unrelated', 'CREATE TABLE business (secret TEXT)'), - ('spoofed', f'PRAGMA user_version=1; PRAGMA application_id={APPLICATION_ID}; CREATE TABLE sessions(id TEXT)'), + for name, setup, reason in ( + ('future', 'PRAGMA user_version=999', 'unsupported-database-schema'), + ('unrelated', 'CREATE TABLE business (secret TEXT)', 'unsupported-database-schema'), + ('spoofed', f'PRAGMA user_version={SCHEMA_VERSION}; PRAGMA application_id={APPLICATION_ID}; CREATE TABLE sessions(id TEXT)', + 'invalid-database-schema'), ): target = Path(self.temporary.name) / name with sqlite3.connect(target) as db: @@ -219,7 +511,7 @@ def test_migration_reopen_unsupported_corrupt_and_spoofed(self): before = target.read_bytes() with redirect_stderr(io.StringIO()): recorder = InteractionRecorder(RecorderConfig(target, 'synthetic'), {}, []) - self.assertEqual(recorder.health['state'], 'degraded') + self.assertEqual((recorder.health['state'], recorder.health['reason']), ('degraded', reason)) self.assertEqual(target.read_bytes(), before) corrupt = Path(self.temporary.name) / 'corrupt' corrupt.write_bytes(b'not sqlite sensitive synthetic') @@ -229,7 +521,25 @@ def test_migration_reopen_unsupported_corrupt_and_spoofed(self): self.assertEqual(recorder.health['state'], 'degraded') self.assertEqual(corrupt.read_bytes(), before) - def test_unsupported_journal_and_page_budget_never_publish_migration(self): + def test_schema_v1_database_is_refused_and_left_untouched(self): + with sqlite3.connect(self.database) as db: + db.executescript(';'.join(V1_DDL) + f';PRAGMA application_id={APPLICATION_ID};PRAGMA user_version=1;' + "INSERT INTO sessions VALUES('historical',1.0,'{}','codex-local','{}',0)") + self.database.chmod(0o600) + before = self.database.read_bytes() + server = self.server() + self.assertEqual(server.dispatch(request('ping'))['result'], {}) + health = server._observer.health + self.assertEqual((health['state'], health['reason'], health['recorded_starts']), + ('degraded', 'unsupported-database-schema', 0)) + server.close() + self.assertEqual(self.database.read_bytes(), before) + self.assertEqual(sorted(path.name for path in self.database.parent.iterdir()), [self.database.name]) + with self.assertRaises(StorageRejected): + report(self.database) + self.assertIn('unsupported-database-schema', self.diagnostics.getvalue()) + + def test_foreign_wal_store_and_page_budget_never_publish_migration(self): for name, pragma in (('wal', 'PRAGMA journal_mode=WAL'),): path = Path(self.temporary.name) / name with sqlite3.connect(path) as db: @@ -238,7 +548,7 @@ def test_unsupported_journal_and_page_budget_never_publish_migration(self): before = path.read_bytes() recorder = InteractionRecorder(RecorderConfig(path, 'synthetic', max_bytes=1024*1024), {}, [], diagnostics=io.StringIO()) - self.assertEqual(recorder.health['state'], 'degraded') + self.assertEqual((recorder.health['state'], recorder.health['reason']), ('degraded', 'nonpristine-database')) self.assertEqual(path.read_bytes(), before) with sqlite3.connect(path) as db: self.assertEqual(db.execute('PRAGMA user_version').fetchone()[0], 0) @@ -307,6 +617,24 @@ def test_private_regular_file_and_no_symlink_or_hardlink(self): self.assertEqual(recorder.health['reason'], 'unsafe-database-file') self.assertEqual(public.stat().st_mode & 0o777, 0o644) + def test_default_location_follows_xdg_and_is_created_private(self): + home = Path(self.temporary.name) / 'home' + with patch.dict(os.environ, {'HOME': str(home), 'XDG_DATA_HOME': ''}): + self.assertEqual(default_database(), home / '.local/share/standards-engine/observations' / DEFAULT_DATABASE_NAME) + with patch.dict(os.environ, {'XDG_DATA_HOME': 'relative/ignored'}): + self.assertEqual(default_database().parents[2], home / '.local/share') + with patch.dict(os.environ, {'XDG_DATA_HOME': str(home / 'xdg')}): + recorder = InteractionRecorder(RecorderConfig(), {'instance_id': 'default', 'catalog_digest': 'c'}, [], + diagnostics=self.diagnostics) + recorder.finish(recorder.begin(request('ping'), request_bytes=1, scope='constructed'), {'result': {}}) + recorder.close() + database = home / 'xdg/standards-engine/observations' / DEFAULT_DATABASE_NAME + self.assertEqual(default_database(), database) + self.assertEqual(recorder.health['recorded_terminals'], 1) + self.assertEqual(stat.S_IMODE(database.stat().st_mode), 0o600) + self.assertEqual(stat.S_IMODE(database.parent.stat().st_mode), 0o700) + self.assertEqual(self.diagnostics.getvalue(), '') + def test_count_age_and_session_retention_and_read_only_reports(self): # Every process-like recorder has its own session; old empty sessions must # disappear along with their interactions rather than accumulating forever. @@ -317,6 +645,7 @@ def test_count_age_and_session_retention_and_read_only_reports(self): summary = report(self.database, limit=1) self.assertEqual(summary['retained_starts'], 16) self.assertEqual(len(self.rows('SELECT id FROM sessions')), 16) + self.assertEqual(len(self.rows('SELECT digest FROM catalogs')), 1, 'one catalog row serves every session') self.assertTrue(summary['session_rows_truncated']) with sqlite3.connect(self.database) as db: db.execute('UPDATE interactions SET started=0') @@ -330,6 +659,8 @@ def test_count_age_and_session_retention_and_read_only_reports(self): for limit in (0, 1001): with self.assertRaises(ValueError): report(self.database, limit=limit) + with self.assertRaises(ValueError): + report(self.database, since_days=0) missing = Path(self.temporary.name) / 'absent.sqlite' with self.assertRaises(FileNotFoundError): report(missing) @@ -343,12 +674,13 @@ def test_retention_can_evict_inflight_evidence_without_disabling_a_live_process( second.dispatch(request('ping')) first._observer.finish(ticket, {'result': {}}, response_bytes=14) self.assertEqual(first._observer.health['state'], 'healthy') - self.assertEqual(first._observer.health['dropped_observations'], 1) + self.assertEqual(first._observer.health['lost'], 1) first.dispatch(request('ping')) self.assertEqual(first._observer.health['recorded_terminals'], 1) summary = report(self.database) self.assertEqual(summary['retained_starts'], 16) self.assertEqual(summary['retained_terminals'], 16) + self.assertEqual(summary['lost_rows'], 1) def test_observed_discovery_and_error_sequences_have_explicit_denominators(self): server = self.server() @@ -403,13 +735,69 @@ def test_report_scope_truncation_and_bounded_scan_are_explicit(self): self.assertTrue(bounded['sequence_scan_truncated']) self.assertIn('input_shape', summary['shapes'][0]) + def test_text_report_answers_the_interface_questions_in_a_screenful(self): + server = self.server() + initialize(server) + thread = {'x-codex-turn-metadata': {'thread_id': 'thread-a', 'thread_source': 'user'}} + self.call(server, 'route', {'facts': {}, 'content': {}}, route_result(('routing.activities', 'routing.topics')), thread) + self.call(server, 'route', {'snapshot': SNAPSHOT, 'facts': {'routing.activities': ['implementation']}}, route_result(), thread) + self.call(server, 'route', {'facts': {'python': True, 'task': 'write a parser test', 'routing.topics': ['security']}}, + rejection('ROUTE.INPUT_INVALID', '/facts'), thread) + for _ in range(2): + self.call(server, 'route', {'facts': {'routing.activities': ['implementation', 'testing']}}, + rejection('ROUTE.INPUT_INVALID', '/facts/routing.activities'), thread) + for target in ('core', 'core', 'router'): + self.call(server, 'read', {'snapshot': SNAPSHOT, 'target': target}, read_result(target), thread) + self.call(server, 'read', {'target': 'python-standards'}, rejection('NAVIGATION.UNKNOWN_POLICY')) + open_call = server._observer.begin(request('ping'), request_bytes=1, scope='constructed') + summary = report(self.database) + text = text_report(summary) + lines = text.splitlines() + self.assertLessEqual(len(lines), 50) + self.assertLessEqual(max(map(len, lines)), 130) + self.assertEqual(lines[2], '11 calls: 1 without an outcome (process ended mid-call), 0 rows lost, 0 pruned by retention') + self.assertRegex(text, r'test 1 +authoring +\d+ +1 +11') + usage = {row['operation']: row for row in summary['usage']} + self.assertEqual((usage['route']['calls'], usage['route']['rejected'], usage['route']['rejection_rate']), (5, 3, 0.6)) + self.assertGreaterEqual(usage['route']['duration_max_ms'], usage['route']['duration_p90_ms']) + self.assertGreaterEqual(usage['route']['duration_p90_ms'], usage['route']['duration_p50_ms']) + self.assertEqual(usage['read']['result_max_bytes'], + max(len(json.dumps(value)) for value in (read_result('router'), rejection('NAVIGATION.UNKNOWN_POLICY')))) + self.assertRegex(text, r'route +5 +60\.0% +[\d.]+ +[\d.]+ +[\d.]+ +[\d.]+ k?B +[\d.]+ k?B') + self.assertIn(' 2 route ROUTE.INPUT_INVALID /facts/routing.activities (fact) ["implementation","testing"]', lines) + self.assertIn(' 1 read NAVIGATION.UNKNOWN_POLICY - {"target":"python-standards"}', lines) + self.assertEqual(summary['unaccepted_facts'], { + 'names': [{'name': 'python', 'count': 1}, {'name': 'task', 'count': 1}], + 'values': [{'fact': 'routing.activities', 'value': 'testing', 'count': 2}]}) + self.assertIn(' names: python x1, task x1', lines) + self.assertIn(' values: routing.activities=testing x2', lines) + # Two route content pages delivered core; three reads returned core, core, router. + self.assertIn(' core x4, router x1', lines) + self.assertEqual(summary['repeat_reads'], {'reads': 5, 'repeats': 3, 'threads': 1, 'threads_repeating': 1, + 'worst_thread_rate': 0.6}) + self.assertIn('Routes sent without a snapshot: 4 of 5 (80.0%)', lines) + self.assertEqual(lines[-3:], ['Tool-calling threads threads calls reads repeated', + 'main 1 8 3 of 5 (60.0%)', + 'unknown 1 1 0 of 0']) + # The window filter drops older calls from every section. + with sqlite3.connect(self.database) as db: + db.execute("UPDATE interactions SET started=started-3*86400 WHERE operation='route'") + recent = report(self.database, since_days=1) + self.assertEqual(recent['retained_starts'], 6) + self.assertNotIn('route', {row['operation'] for row in recent['usage']}) + self.assertIn('(last 1 days)', text_report(recent)) + server._observer.finish(open_call, {'result': {}}) + def test_arbitrary_outputs_are_never_retained(self): server = self.server() initialize(server) secret = 'SYNTHETIC_OUTPUT_CREDENTIAL' - result = {'structuredContent': {'body': secret, 'outcome': secret, + result = {'structuredContent': {'body': secret, 'outcome': secret, 'kind': secret, 'code': secret, 'status': secret, + 'content': {'offset': secret, 'total': secret, 'items': [{'policy': {'id': secret + ' prose'}, 'content': secret}]}, + 'reading_plan': [{'target': secret + ' prose', 'state': 'selected'}], 'input_feedback': {'issues': [{'instance_pointer': '/' + secret, - 'keyword': secret, 'message': secret}]}}, 'isError': True} + 'keyword': secret, 'message': secret}]}}, 'isError': True, + 'content': [{'type': 'text', 'text': secret}]} with patch.object(server, '_request', return_value=result): response = server.dispatch(request('tools/call', {'name': 'runtime_info', 'arguments': {}})) self.assertEqual(response['result'], result) @@ -422,59 +810,135 @@ def test_unencodable_text_measurement_never_changes_stdio_behavior(self): server = self.server() if observed else MCPServer(ROOT, purpose='authoring') self.addCleanup(server.close) output = io.StringIO() - payload = '{"jsonrpc":"2.0","id":"\ud800","method":"ping"}\n' + payload = '{"jsonrpc":"2.0","id":"\ud800","method":"ping","params":{"_meta":{"threadId":"\ud800"}}}\n' serve(server, io.StringIO(payload), output) self.assertEqual(json.loads(output.getvalue())['result'], {}) + self.assertEqual(report(self.database)['retained_terminals'], 1) + def test_no_test_or_harness_launch_can_reach_the_default_database(self): + # Always-on recording must not follow the test suite into a developer's home. + # In-process MCPServer construction records only when given a configuration; + # every file that launches the server module as a process must disable + # recording or name a database explicitly. + launch = re.compile(r'''standards_engine\.mcp["']|standards_engine\.mcp import main''') + guards = ('--no-observe', '--observe-database', 'STANDARDS_ENGINE_OBSERVE') + launchers = [path for folder in ('tools', 'evaluation', '.agents') for path in sorted((ROOT / folder).rglob('*.py')) + if launch.search(path.read_text())] + self.assertGreater(len(launchers), 20) + for path in launchers: + self.assertTrue(any(guard in path.read_text() for guard in guards), path) class ProcessTests(unittest.TestCase): + def setUp(self): + self.temporary = tempfile.TemporaryDirectory() + self.addCleanup(self.temporary.cleanup) + self.home = Path(self.temporary.name) / 'home' + self.home.mkdir() + self.database = Path(self.temporary.name) / 'observer.sqlite' + + def census(self): + with sqlite3.connect(self.database) as db: + self.assertEqual(db.execute('PRAGMA integrity_check').fetchone()[0], 'ok') + self.assertEqual(db.execute('PRAGMA foreign_key_check').fetchall(), []) + return (db.execute('SELECT count(*) FROM interactions').fetchone()[0], + db.execute('SELECT count(*) FROM events').fetchone()[0], + db.execute('SELECT count(*) FROM (SELECT 1 FROM interactions i JOIN events e ON e.interaction=i.id ' + 'GROUP BY i.session HAVING count(*)=22)').fetchone()[0], + db.execute('SELECT coalesce(sum(lost),0) FROM sessions').fetchone()[0]) + + def test_always_on_by_default_in_both_purposes_invisible_and_two_off_switches(self): + messages = [request('initialize', {'protocolVersion': '2025-11-25', 'capabilities': {}, + 'clientInfo': {'name': 'default-on-fixture', 'version': '7'}}), + {'jsonrpc': '2.0', 'method': 'notifications/initialized'}, request('tools/list', identifier=2), + request('tools/call', {'name': 'runtime_info', 'arguments': {}}, identifier=3)] + payload = ''.join(json.dumps(message) + '\n' for message in messages) + def run(purpose, *flags, **variables): + process = subprocess.run([sys.executable, '-m', MCP_MODULE, '--repo-root', str(ROOT), '--purpose', purpose, *flags], + cwd=ROOT, env=environment(self.home, **variables), input=payload, + capture_output=True, text=True, timeout=60) + self.assertEqual(process.returncode, 0, process.stderr) + self.assertEqual(process.stderr, '', 'recording health is silent unless something is wrong') + return re.sub('[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}', 'INSTANCE', process.stdout) + silent = [run('application', '--no-observe'), run('application', STANDARDS_ENGINE_OBSERVE='off'), + run('application', '--observe-database', str(self.database), STANDARDS_ENGINE_OBSERVE=' OFF ')] + self.assertEqual(list(self.home.iterdir()), [], 'both off switches leave no file or directory') + self.assertFalse(self.database.exists()) + observed = run('application') + self.assertEqual({observed}, set(silent), 'recording changes no protocol byte') + run('authoring') + default = self.home / '.local/share/standards-engine/observations' / DEFAULT_DATABASE_NAME + self.assertEqual(stat.S_IMODE(default.stat().st_mode), 0o600) + self.assertEqual(stat.S_IMODE(default.parent.stat().st_mode), 0o700) + summary = report(default) + self.assertEqual((summary['retained_starts'], summary['retained_terminals']), (6, 6)) + self.assertEqual([(row['client'], row['purpose'], row['sessions'], row['calls']) for row in summary['clients']], + [('default-on-fixture 7', 'application', 1, 3), ('default-on-fixture 7', 'authoring', 1, 3)]) + self.assertEqual({row['deployment'] for row in summary['sessions']}, {'local'}) + run('application', XDG_DATA_HOME=str(self.home / 'xdg'), STANDARDS_ENGINE_OBSERVE='on') + self.assertEqual(report(self.home / 'xdg/standards-engine/observations' / DEFAULT_DATABASE_NAME)['retained_starts'], 3) + run('application', '--observe-database', str(self.database), '--observe-deployment', 'explicit') + self.assertEqual(report(self.database)['sessions'][0]['deployment'], 'explicit') + self.assertEqual(report(default)['retained_starts'], 6) + def test_cold_stdio_restart_bytes_identity_and_operator_cli(self): - with tempfile.TemporaryDirectory() as temporary: - database = Path(temporary) / 'observer.sqlite' - messages = [request('initialize', {'protocolVersion': '2025-11-25', 'capabilities': {}, 'clientInfo': {}}), - {'jsonrpc': '2.0', 'method': 'notifications/initialized'}, request('tools/list'), - request('tools/call', {'name': 'describe_input', 'arguments': {'operation': 'runtime_info'}}), - request('tools/call', {'name': 'runtime_info', 'arguments': {'unexpected': 'SYNTHETIC_SECRET'}}), - request('tools/call', {'name': 'runtime_info', 'arguments': {}})] - payload = ''.join(json.dumps(message) + '\n' for message in messages) - command = [sys.executable, '-m', MCP_MODULE, '--repo-root', str(ROOT), '--purpose', 'authoring', - '--output-schemas', 'on-demand', '--observe-database', str(database), '--observe-deployment', 'cold-test'] - identities = [] - for _ in range(2): - process = subprocess.run(command, cwd=ROOT, input=payload, capture_output=True, text=True, timeout=30) - self.assertEqual(process.returncode, 0, process.stderr) - responses = [json.loads(line) for line in process.stdout.splitlines()] - identity = responses[0]['result']['_meta']['standards-engine/runtime'] - identities.append(identity) - with sqlite3.connect(database) as db: - row = db.execute('SELECT runtime FROM sessions WHERE id=?', (identity['instance_id'],)).fetchone() - self.assertEqual(json.loads(row[0]), identity) - counts = db.execute('SELECT sum(request_bytes) FROM interactions WHERE session=?', (identity['instance_id'],)).fetchone()[0] - notification_bytes = len((json.dumps(messages[1]) + '\n').encode()) - self.assertEqual(counts, len(payload.encode()) - notification_bytes) - output_bytes = db.execute('SELECT sum(e.response_bytes) FROM events e JOIN interactions i ' - 'ON i.id=e.interaction WHERE session=?', (identity['instance_id'],)).fetchone()[0] - self.assertEqual(output_bytes, len(process.stdout.encode())) - self.assertIn('"state":"healthy"', process.stderr) - self.assertNotEqual(identities[0]['instance_id'], identities[1]['instance_id']) - for key in ('implementation_digest', 'schema_digest', 'catalog_digest', 'interface_version'): - self.assertEqual(identities[0][key], identities[1][key]) - summary = report(database) - self.assertEqual(summary['retained_starts'], 10) - self.assertEqual(summary['retained_terminals'], 10) - self.assertEqual({row['scope'] for row in summary['operations']}, {'stdio-flushed'}) - before = database.read_bytes() - result = subprocess.run([sys.executable, '-m', MODULE, '--database', str(database), '--limit', '2'], - cwd=ROOT, capture_output=True, text=True, timeout=30) - self.assertEqual(result.returncode, 0, result.stderr) - self.assertEqual(json.loads(result.stdout)['retained_starts'], 10) - self.assertEqual(database.read_bytes(), before) + messages = [request('initialize', {'protocolVersion': '2025-11-25', 'capabilities': {}, 'clientInfo': {}}), + {'jsonrpc': '2.0', 'method': 'notifications/initialized'}, request('tools/list'), + request('tools/call', {'name': 'describe_input', 'arguments': {'operation': 'runtime_info'}}), + request('tools/call', {'name': 'runtime_info', 'arguments': {'unexpected': 'SYNTHETIC_SECRET'}}), + request('tools/call', {'name': 'runtime_info', 'arguments': {}})] + payload = ''.join(json.dumps(message) + '\n' for message in messages) + command = [sys.executable, '-m', MCP_MODULE, '--repo-root', str(ROOT), '--purpose', 'authoring', + '--output-schemas', 'on-demand', '--observe-database', str(self.database), '--observe-deployment', 'cold-test'] + identities = [] + for _ in range(2): + process = subprocess.run(command, cwd=ROOT, env=environment(self.home), input=payload, + capture_output=True, text=True, timeout=30) + self.assertEqual(process.returncode, 0, process.stderr) + self.assertEqual(process.stderr, '') + responses = [json.loads(line) for line in process.stdout.splitlines()] + identity = responses[0]['result']['_meta']['standards-engine/runtime'] + identities.append(identity) + with sqlite3.connect(self.database) as db: + row = db.execute('SELECT runtime FROM sessions WHERE id=?', (identity['instance_id'],)).fetchone() + self.assertEqual(json.loads(row[0]), identity) + counts = db.execute('SELECT sum(request_bytes) FROM interactions WHERE session=?', (identity['instance_id'],)).fetchone()[0] + notification_bytes = len((json.dumps(messages[1]) + '\n').encode()) + self.assertEqual(counts, len(payload.encode()) - notification_bytes) + output_bytes, result_bytes = db.execute( + 'SELECT sum(e.response_bytes),sum(e.result_bytes) FROM events e JOIN interactions i ' + 'ON i.id=e.interaction WHERE session=?', (identity['instance_id'],)).fetchone() + self.assertEqual(output_bytes, len(process.stdout.encode())) + self.assertEqual(result_bytes, sum(len(response['result']['content'][0]['text']) for response in responses[2:])) + self.assertLess(2 * result_bytes, output_bytes) + self.assertNotEqual(identities[0]['instance_id'], identities[1]['instance_id']) + for key in ('implementation_digest', 'schema_digest', 'catalog_digest', 'interface_version'): + self.assertEqual(identities[0][key], identities[1][key]) + summary = report(self.database) + self.assertEqual(summary['retained_starts'], 10) + self.assertEqual(summary['retained_terminals'], 10) + self.assertEqual({row['scope'] for row in summary['operations']}, {'stdio-flushed'}) + before = self.database.read_bytes() + cli = [sys.executable, '-m', MODULE, '--database', str(self.database)] + result = subprocess.run(cli + ['--format', 'json', '--limit', '2'], cwd=ROOT, env=environment(self.home), + capture_output=True, text=True, timeout=30) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(json.loads(result.stdout)['retained_starts'], 10) + self.assertLess(len(result.stdout), 16_000, 'no per-session schema digests in the report') + result = subprocess.run(cli + ['--since-days', '1'], cwd=ROOT, env=environment(self.home), + capture_output=True, text=True, timeout=30) + self.assertEqual(result.returncode, 0, result.stderr) + self.assertIn('10 calls: 0 without an outcome', result.stdout) + self.assertRegex(result.stdout, r'runtime_info +4 +50\.0%') + self.assertNotIn('SYNTHETIC_SECRET', result.stdout) + self.assertEqual(self.database.read_bytes(), before) + # Without --database the report reads the always-on location, here an empty home. + result = subprocess.run(cli[:3], cwd=ROOT, env=environment(self.home), capture_output=True, text=True, timeout=30) + self.assertEqual((result.returncode, result.stdout), (1, '')) + self.assertEqual(list(self.home.iterdir()), []) def test_process_kill_leaves_unmatched_start_and_replacement_does_not_complete_it(self): - with tempfile.TemporaryDirectory() as temporary: - database = Path(temporary) / 'observer.sqlite' - script = ''' + script = ''' import sys, threading from pathlib import Path from tools.standards_engine.standards_engine.mcp import MCPServer, serve @@ -486,62 +950,119 @@ def blocked(method, params): server._request=blocked serve(server,sys.stdin,sys.stdout) ''' - process = subprocess.Popen([sys.executable, '-c', script, str(ROOT), str(database)], cwd=ROOT, - stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) - try: - process.stdin.write(json.dumps(request('ping')) + '\n') - process.stdin.flush() - self.assertIn('healthy', process.stderr.readline()) - self.assertEqual(process.stderr.readline().strip(), 'entered-domain') + process = subprocess.Popen([sys.executable, '-c', script, str(ROOT), str(self.database)], cwd=ROOT, + env=environment(self.home), + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) + try: + process.stdin.write(json.dumps(request('ping')) + '\n') + process.stdin.flush() + self.assertEqual(process.stderr.readline().strip(), 'entered-domain') + process.kill() + process.communicate(timeout=10) + finally: + if process.poll() is None: process.kill() process.communicate(timeout=10) - finally: - if process.poll() is None: - process.kill() - process.communicate(timeout=10) - replacement = subprocess.run([sys.executable, '-m', MCP_MODULE, '--purpose', 'authoring', - '--observe-database', str(database), '--observe-deployment', 'replacement'], - cwd=ROOT, input=json.dumps(request('ping')) + '\n', - text=True, capture_output=True, timeout=30) - self.assertEqual(replacement.returncode, 0, replacement.stderr) - summary = report(database) - self.assertEqual(summary['retained_starts'], 2) - self.assertEqual(summary['retained_terminals'], 1) - self.assertEqual(summary['unmatched_starts'], 1) - - def test_concurrent_processes_and_first_open_never_overwrite_or_duplicate(self): - with tempfile.TemporaryDirectory() as temporary: - database = Path(temporary) / 'observer.sqlite' - command = [sys.executable, '-m', MCP_MODULE, '--purpose', 'authoring', - '--observe-database', str(database), '--observe-deployment', 'concurrent'] - workers = [subprocess.Popen(command, cwd=ROOT, stdin=subprocess.PIPE, stdout=subprocess.PIPE, - stderr=subprocess.PIPE, text=True) for _ in range(4)] - try: - outputs = [] - for worker in workers: - worker.stdin.write(''.join(json.dumps(request('ping', identifier=i)) + '\n' for i in range(5))) - worker.stdin.flush() - for worker in workers: - output, errors = worker.communicate(timeout=30) - self.assertEqual(worker.returncode, 0, errors) - self.assertEqual(len(output.splitlines()), 5) - outputs.append(errors) - finally: - for worker in workers: - if worker.poll() is None: - worker.kill() - worker.communicate(timeout=10) - # Contention may intentionally degrade a process after the 20ms budget. - # A failed terminal write may leave an unmatched begin; no duplicate or - # fabricated terminal is permitted. Domain replies still total 20. - summary = report(database) - self.assertGreater(summary['retained_starts'], 0) - self.assertLessEqual(summary['retained_starts'], 20) - self.assertLessEqual(summary['retained_terminals'], summary['retained_starts']) - with sqlite3.connect(database) as db: - self.assertEqual(db.execute('PRAGMA integrity_check').fetchone()[0], 'ok') - self.assertEqual(db.execute('PRAGMA foreign_key_check').fetchall(), []) - self.assertTrue(all('healthy' in output or 'degraded' in output for output in outputs)) + replacement = subprocess.run([sys.executable, '-m', MCP_MODULE, '--purpose', 'authoring', + '--observe-database', str(self.database), '--observe-deployment', 'replacement'], + cwd=ROOT, env=environment(self.home), input=json.dumps(request('ping')) + '\n', + text=True, capture_output=True, timeout=30) + self.assertEqual(replacement.returncode, 0, replacement.stderr) + summary = report(self.database) + self.assertEqual(summary['retained_starts'], 2) + self.assertEqual(summary['retained_terminals'], 1) + self.assertEqual(summary['unmatched_starts'], 1) + self.assertIn('2 calls: 1 without an outcome', text_report(summary)) + + def test_eight_recorders_creating_one_database_at_the_same_instant_lose_nothing(self): + script = ''' +import io, sys, time +from pathlib import Path +from tools.standards_engine.standards_engine.interaction_observer import InteractionRecorder, RecorderConfig +while time.time() < float(sys.argv[2]): + pass +recorder = InteractionRecorder(RecorderConfig(Path(sys.argv[1]), 'simultaneous'), {'instance_id': sys.argv[3], 'catalog_digest': 'c'}, + [{'name': 'runtime_info', 'inputSchema': {'type': 'object'}}], diagnostics=io.StringIO()) +calls = [('initialize', {}), ('tools/list', {})] + [('tools/call', {'name': 'runtime_info', 'arguments': {}})] * 20 +for identifier, (method, params) in enumerate(calls): + ticket = recorder.begin({'jsonrpc': '2.0', 'id': identifier, 'method': method, 'params': params}, request_bytes=1, scope='constructed') + recorder.finish(ticket, {'result': {}}, response_bytes=1) +recorder.close() +''' + for attempt in range(3): + self.database = Path(self.temporary.name) / f'simultaneous-{attempt}.sqlite' + instant = time.time() + 1.5 # After every interpreter has imported the Engine. + workers = [subprocess.Popen([sys.executable, '-c', script, str(self.database), str(instant), f'worker-{index}'], + cwd=ROOT, env=environment(self.home), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) + for index in range(8)] + for worker in workers: + output, errors = worker.communicate(timeout=60) + self.assertEqual(worker.returncode, 0, errors) + self.assertEqual(self.census(), (176, 176, 8, 0)) + + def servers(self, count=8): + command = [sys.executable, '-m', MCP_MODULE, '--repo-root', str(ROOT), '--purpose', 'application', + '--output-schemas', 'on-demand', '--observe-database', str(self.database)] + return [subprocess.Popen(command, cwd=ROOT, env=environment(self.home), stdin=subprocess.PIPE, + stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) for _ in range(count)] + + def lines(self, *messages): + return ''.join(json.dumps(message) + '\n' for message in messages) + + def collect(self, workers, responses): + errors = [] + try: + for worker in workers: + output, error = worker.communicate(timeout=60) + self.assertEqual(worker.returncode, 0, error) + self.assertEqual(len(output.splitlines()), responses) + errors.append(error) + finally: + for worker in workers: + if worker.poll() is None: + worker.kill() + worker.communicate(timeout=10) + return errors + + def test_eight_server_processes_started_together_record_every_call(self): + opening = self.lines(request('initialize', {'protocolVersion': '2025-11-25', 'capabilities': {}, + 'clientInfo': {'name': 'fan-out', 'version': '1'}}), + {'jsonrpc': '2.0', 'method': 'notifications/initialized'}) + calls = self.lines(request('tools/list', identifier=2), + *(request('tools/call', {'name': 'runtime_info', 'arguments': {}}, identifier=3 + index) for index in range(20))) + # No database exists yet: all eight create it while starting. + workers = self.servers() + for worker in workers: + worker.stdin.write(opening + calls) + worker.stdin.flush() + self.collect(workers, 22) + self.assertEqual(self.census(), (176, 176, 8, 0)) + # Again while another connection holds the write lock for 500 ms. + workers = self.servers() + try: + for worker in workers: + worker.stdin.write(opening) + worker.stdin.flush() + for worker in workers: + self.assertIn('"result"', worker.stdout.readline()) + lock = sqlite3.connect(self.database, isolation_level=None) + lock.execute('BEGIN IMMEDIATE') + for worker in workers: + worker.stdin.write(calls) + worker.stdin.flush() + time.sleep(0.5) + self.assertEqual(self.census()[0], 184, 'nothing is written while the lock is held') + lock.execute('ROLLBACK') + lock.close() + finally: + errors = self.collect(workers, 21) + self.assertEqual(self.census(), (352, 352, 16, 0)) + locked = [error for error in errors if '"reason":"storage-locked"' in error] + self.assertTrue(locked, 'the lock must have forced at least one process to use its backlog') + for error in errors: + if error: + final = json.loads(error.splitlines()[-1].split(' ', 2)[2]) + self.assertEqual((final['state'], final['backlog'], final['lost']), ('healthy', 0, 0)) if __name__ == '__main__': diff --git a/tools/standards_engine/tests/test_mcp.py b/tools/standards_engine/tests/test_mcp.py index 6547ef9b..8c8ff6eb 100644 --- a/tools/standards_engine/tests/test_mcp.py +++ b/tools/standards_engine/tests/test_mcp.py @@ -396,6 +396,7 @@ def test_module_stdio_launch_from_unrelated_working_directory(self): "authoring", "--repo-root", str(ROOT), + "--no-observe", ], input="".join(json.dumps(message) + "\n" for message in messages), text=True, diff --git a/tools/standards_engine/tests/test_navigation_indexes.py b/tools/standards_engine/tests/test_navigation_indexes.py index 7508828e..c999ecf2 100644 --- a/tools/standards_engine/tests/test_navigation_indexes.py +++ b/tools/standards_engine/tests/test_navigation_indexes.py @@ -387,6 +387,7 @@ def test_fresh_mcp_process_exposes_snapshot_bound_navigation(self): "authoring", "--repo-root", str(self.root), + "--no-observe", ], input="".join(json.dumps(message) + "\n" for message in messages), text=True, diff --git a/tools/standards_engine/tests/test_numeric_boundary.py b/tools/standards_engine/tests/test_numeric_boundary.py index 202f7fa3..e8a6bb37 100644 --- a/tools/standards_engine/tests/test_numeric_boundary.py +++ b/tools/standards_engine/tests/test_numeric_boundary.py @@ -111,7 +111,7 @@ def cold_call(self, operation, arguments, rejected=False): ] result = subprocess.run([sys.executable, '-P', '-m', 'tools.standards_engine.standards_engine.mcp', '--repo-root', str(self.root), - '--purpose', 'authoring', '--output-schemas', 'on-demand', '--advanced'], + '--purpose', 'authoring', '--output-schemas', 'on-demand', '--advanced', '--no-observe'], input=''.join(json.dumps(m) + '\n' for m in messages), text=True, capture_output=True, env={**os.environ, 'PYTHONPATH': str(ROOT)}, timeout=90) self.assertEqual(result.returncode, 0, result.stderr) diff --git a/tools/standards_engine/tests/test_output_delivery.py b/tools/standards_engine/tests/test_output_delivery.py index 7a0cafd1..06466ae7 100644 --- a/tools/standards_engine/tests/test_output_delivery.py +++ b/tools/standards_engine/tests/test_output_delivery.py @@ -213,7 +213,7 @@ def run(call): messages=[init,{'jsonrpc':'2.0','method':'notifications/initialized'},request('tools/list',identifier=2), request('tools/call',{'name':'describe_output','arguments':call},identifier=3)] process=subprocess.run([sys.executable,'-m','tools.standards_engine.standards_engine.mcp', - '--repo-root',str(ROOT),'--purpose','authoring','--output-schemas','on-demand'], + '--repo-root',str(ROOT),'--purpose','authoring','--output-schemas','on-demand','--no-observe'], input=''.join(json.dumps(x)+'\n' for x in messages),capture_output=True,text=True,cwd=ROOT,check=True) replies=[json.loads(x) for x in process.stdout.splitlines()] self.assertTrue(all('outputSchema' not in t for t in replies[1]['result']['tools'])) diff --git a/tools/standards_engine/tests/test_process_reuse.py b/tools/standards_engine/tests/test_process_reuse.py index b09716d7..6e8a0507 100644 --- a/tools/standards_engine/tests/test_process_reuse.py +++ b/tools/standards_engine/tests/test_process_reuse.py @@ -220,7 +220,7 @@ def test_real_stdio_restarts_read_the_same_retained_snapshot(self): for _ in range(2): completed = subprocess.run( [sys.executable, "-P", "-m", "tools.standards_engine.standards_engine.mcp", - "--repo-root", str(self.root), "--purpose", "authoring"], + "--repo-root", str(self.root), "--purpose", "authoring", "--no-observe"], input="".join(json.dumps(value) + "\n" for value in messages), text=True, capture_output=True, check=True, timeout=60, cwd=self.temporary.name, env={**os.environ, "PYTHONPATH": str(ROOT)}, diff --git a/tools/standards_engine/tests/test_proposal_reuse.py b/tools/standards_engine/tests/test_proposal_reuse.py index afa9cfa6..5937100a 100644 --- a/tools/standards_engine/tests/test_proposal_reuse.py +++ b/tools/standards_engine/tests/test_proposal_reuse.py @@ -495,7 +495,7 @@ def test_two_fresh_stdio_servers_reproduce_same_historical_draft(self): observed = [] for _ in range(2): process = subprocess.run( - [sys.executable, "-P", "-m", "tools.standards_engine.standards_engine.mcp", "--repo-root", str(self.root), "--purpose", "authoring"], + [sys.executable, "-P", "-m", "tools.standards_engine.standards_engine.mcp", "--repo-root", str(self.root), "--purpose", "authoring", "--no-observe"], input="".join(json.dumps(item) + "\n" for item in messages), text=True, capture_output=True, check=True, timeout=90, env={**os.environ, "PYTHONPATH": str(ROOT)}, cwd=self.temporary.name, diff --git a/tools/standards_engine/tests/test_purpose_transport.py b/tools/standards_engine/tests/test_purpose_transport.py index d96351ba..ba18e8a7 100644 --- a/tools/standards_engine/tests/test_purpose_transport.py +++ b/tools/standards_engine/tests/test_purpose_transport.py @@ -98,7 +98,7 @@ def request(identifier, method, params): ] process = subprocess.run( [sys.executable, "-P", "-m", "tools.standards_engine.standards_engine.mcp", - "--repo-root", str(self.root), "--purpose", "application", "--advanced"], + "--repo-root", str(self.root), "--purpose", "application", "--advanced", "--no-observe"], input="".join(json.dumps(value) + "\n" for value in messages), text=True, capture_output=True, env={**os.environ, "PYTHONPATH": str(ROOT)}, timeout=120, ) diff --git a/tools/standards_engine/tests/test_read_many.py b/tools/standards_engine/tests/test_read_many.py index 2813135c..74414e30 100644 --- a/tools/standards_engine/tests/test_read_many.py +++ b/tools/standards_engine/tests/test_read_many.py @@ -208,7 +208,7 @@ def message(i, method, params): {"jsonrpc": "2.0", "method": "notifications/initialized"}, message(2, "tools/call", {"name": "read_many", "arguments": arguments}), message(3, "tools/call", {"name": "read_many", "arguments": {**arguments, "items": [{"target": "core"}, {"target": "provenance.fixture"}]}})] - command = [sys.executable, "-P", "-m", "tools.standards_engine.standards_engine.mcp", "--repo-root", str(self.root), "--purpose", "application"] + command = [sys.executable, "-P", "-m", "tools.standards_engine.standards_engine.mcp", "--repo-root", str(self.root), "--purpose", "application", "--no-observe"] for _ in range(2): response = subprocess.run(command, input="".join(json.dumps(m) + "\n" for m in messages), text=True, capture_output=True, env=env, timeout=60) self.assertEqual(response.returncode, 0, response.stderr) diff --git a/tools/standards_engine/tests/test_routing_fact_transport.py b/tools/standards_engine/tests/test_routing_fact_transport.py index b46acb04..faaefbf6 100644 --- a/tools/standards_engine/tests/test_routing_fact_transport.py +++ b/tools/standards_engine/tests/test_routing_fact_transport.py @@ -88,7 +88,7 @@ def cold(self, purpose, operation, args, *, error=False): {'jsonrpc':'2.0','method':'notifications/initialized'}, {'jsonrpc':'2.0','id':2,'method':'tools/call','params':{'name':operation,'arguments':args}}] proc=subprocess.run([sys.executable,'-P','-m','tools.standards_engine.standards_engine.mcp', - '--repo-root',str(self.root),'--purpose',purpose,'--output-schemas','on-demand'], + '--repo-root',str(self.root),'--purpose',purpose,'--output-schemas','on-demand','--no-observe'], cwd=ROOT,env={**os.environ,'PYTHONPATH':str(ROOT)},input=''.join(json.dumps(m)+'\n' for m in messages), capture_output=True,text=True,check=True) self.assertEqual(proc.stderr,'') diff --git a/tools/standards_engine/tests/test_runtime_identity.py b/tools/standards_engine/tests/test_runtime_identity.py index ae5bdd72..0a03ecef 100644 --- a/tools/standards_engine/tests/test_runtime_identity.py +++ b/tools/standards_engine/tests/test_runtime_identity.py @@ -100,7 +100,7 @@ def test_actual_mcp_and_cli_observe_without_a_git_repository(self): request('tools/call', {'name': 'runtime_info', 'arguments': {}}, identifier=2)] environment = {**os.environ, 'PYTHONPATH': str(ROOT)} mcp = subprocess.run([sys.executable, '-P', '-m', 'tools.standards_engine.standards_engine.mcp', - '--repo-root', str(root), '--purpose', 'application', '--advanced'], + '--repo-root', str(root), '--purpose', 'application', '--advanced', '--no-observe'], input=''.join(json.dumps(item)+'\n' for item in messages), text=True, capture_output=True, env=environment, timeout=60) self.assertEqual(mcp.returncode, 0, mcp.stderr) diff --git a/tools/standards_engine/tests/test_schema_presentation.py b/tools/standards_engine/tests/test_schema_presentation.py index f3d96f87..4da1b27d 100644 --- a/tools/standards_engine/tests/test_schema_presentation.py +++ b/tools/standards_engine/tests/test_schema_presentation.py @@ -115,7 +115,7 @@ def test_retired_cli_flags_reject_without_creating_paths(self): with tempfile.TemporaryDirectory() as temporary: root = Path(temporary) / 'untouched' commands = ( - ('tools.standards_engine.standards_engine.mcp', ['--repo-root', str(root), '--purpose', 'authoring']), + ('tools.standards_engine.standards_engine.mcp', ['--repo-root', str(root), '--purpose', 'authoring', '--no-observe']), ('tools.standards_engine.tests.catalog_inventory', ['--repo-root', str(root)]), ('tools.standards_engine.tests.codex_navigation_client', []), ('tools.standards_engine.tests.codex_discovery_client', ['--model', 'fixture', '--surface', 'fixture', '--evidence-dir', str(root)]), diff --git a/tools/standards_engine/tests/test_storage_lifecycle_transport.py b/tools/standards_engine/tests/test_storage_lifecycle_transport.py index 0ff707b7..6e84b144 100644 --- a/tools/standards_engine/tests/test_storage_lifecycle_transport.py +++ b/tools/standards_engine/tests/test_storage_lifecycle_transport.py @@ -65,7 +65,7 @@ def cold_open_failure(self): process = subprocess.run( [sys.executable, '-P', '-m', 'tools.standards_engine.standards_engine.mcp', '--repo-root', str(self.root), '--purpose', 'authoring', - '--output-schemas', 'on-demand'], + '--output-schemas', 'on-demand', '--no-observe'], env={**os.environ, 'PYTHONPATH': str(transport.fixture.ROOT)}, input=''.join(json.dumps(message) + '\n' for message in messages), text=True, capture_output=True, timeout=90, diff --git a/tools/standards_engine/tests/test_typed_routing_workflow.py b/tools/standards_engine/tests/test_typed_routing_workflow.py index 44a12cc9..6d3e6c19 100644 --- a/tools/standards_engine/tests/test_typed_routing_workflow.py +++ b/tools/standards_engine/tests/test_typed_routing_workflow.py @@ -36,7 +36,7 @@ def call(self, operation, arguments, delivery='on-demand', *, error=False): {'jsonrpc':'2.0','method':'notifications/initialized'}, request('tools/call', {'name':operation,'arguments':arguments}, 2)] run = subprocess.run([sys.executable,'-P','-m','tools.standards_engine.standards_engine.mcp', - '--repo-root',str(self.root),'--purpose','authoring','--output-schemas',delivery], + '--repo-root',str(self.root),'--purpose','authoring','--output-schemas',delivery,'--no-observe'], input=''.join(json.dumps(v)+'\n' for v in messages),text=True,capture_output=True,check=True, cwd=ROOT,env={**os.environ,'PYTHONPATH':str(ROOT)}) self.assertEqual(run.stderr, '') diff --git a/tools/standards_engine/tests/test_workflow_presentation.py b/tools/standards_engine/tests/test_workflow_presentation.py index 3636bc84..6b95da24 100644 --- a/tools/standards_engine/tests/test_workflow_presentation.py +++ b/tools/standards_engine/tests/test_workflow_presentation.py @@ -310,7 +310,7 @@ def call(arguments): root = Path(__file__).resolve().parents[3] run = subprocess.run( [sys.executable, "-P", "-m", "tools.standards_engine.standards_engine.mcp", - "--repo-root", str(self.root), "--purpose", "authoring"], + "--repo-root", str(self.root), "--purpose", "authoring", "--no-observe"], input="".join(json.dumps(item) + "\n" for item in messages), text=True, capture_output=True, env={**os.environ, "PYTHONPATH": str(root)}, check=True, diff --git a/tools/standards_engine/tests/workflow_interaction_trace.py b/tools/standards_engine/tests/workflow_interaction_trace.py index 1de38251..d8df0ddb 100644 --- a/tools/standards_engine/tests/workflow_interaction_trace.py +++ b/tools/standards_engine/tests/workflow_interaction_trace.py @@ -38,7 +38,7 @@ def call(name: str, arguments: dict) -> dict: ] completed = subprocess.run( [sys.executable, "-P", "-m", "tools.standards_engine.standards_engine.mcp", - "--repo-root", str(root), "--purpose", "authoring"], + "--repo-root", str(root), "--purpose", "authoring", "--no-observe"], input="".join(json.dumps(item) + "\n" for item in messages), text=True, capture_output=True, check=True, env=os.environ.copy(), ) From 92cfbdcfe460b24eca837c6a08ef90db7692a26f Mon Sep 17 00:00:00 2001 From: MrScripty Date: Thu, 12 Nov 2026 07:22:20 -0700 Subject: [PATCH 4/4] feat(engine): deliver every selected standard to application agents, labelled Application approval was a gate: one module without a current approval anywhere in a selection rejected the whole route with "awaiting application publication", naming nothing. 40 of 85 registered materials are not currently approved, including two of three application profiles, and any edit to Core or the Router would have taken every application call offline until re-approval. In recorded use, 43 of 91 application routes were rejected this way and agents responded by deleting true facts from their queries. Approval is now a label. This is interface 49. - Every registered material a call selects or names is delivered. Each read result and each reading-plan entry carries review_state: current, changed-since-review or not-reviewed. The approval manifest and the authoring-side exposure workflow are unchanged. - An unregistered or misspelt identity is rejected as APPLICATION.UNKNOWN_TARGET, and a traversal a relationship group does not permit as APPLICATION.TRAVERSAL_NOT_PERMITTED. APPLICATION.CONTENT_UNAVAILABLE is removed. - Application route content pages are sized for inline display: about 40 KiB of structured result by default (--route-page-bytes, 8 KiB to 2 MiB), always at least one whole module. The previous 2 MiB bound produced pages the client diverted to a file. Authoring paging is unchanged. - The application connection instructions and tool descriptions are rewritten in plain language: what the server is for, the sequence of calls, snapshot reuse and what the labels mean. A new application skill, .agents/skills/coding-standards/SKILL.md, teaches the same sequence with a worked example taken from real engine output. - Tests that hard-coded the interface number now read it from the installed interface. The generated contract and tool catalog are regenerated by the repository generator. The CI path filter gains the new skill folder. One current guide, docs/guides/positive-guidance-and-provenance.md, still describes the gate. It is pinned by a coverage certificate and is left for a certificate retirement. Co-Authored-By: Claude Fable 5.2 --- .agents/skills/coding-standards/SKILL.md | 143 ++++++++++++++ .agents/skills/standards-engine/SKILL.md | 4 +- .../standards-engine/references/authoring.md | 8 +- .../references/environment.md | 20 +- .../standards-engine/references/navigation.md | 47 +++-- .../workflows/purpose-separated-engine.yml | 1 + .../generated/suite-inputs.json | 32 ++-- tools/standards_engine/PURPOSE-SEPARATION.md | 135 ++++++++++--- tools/standards_engine/README.md | 24 ++- tools/standards_engine/contracts/README.md | 13 +- .../contracts/a1-contract.schema.json | 37 +++- .../contracts/a1-interface.toml | 4 +- .../contracts/examples/a1-examples.json | 6 +- .../contracts/generated/agent-tools.json | 41 +++- .../standards_engine/_generated_contract.py | 20 +- .../standards_engine/agent_navigation.py | 36 +++- .../standards_engine/context_projection.py | 99 +++++----- .../standards_engine/engine.py | 11 ++ .../standards_engine/standards_engine/mcp.py | 45 ++++- .../standards_engine/mcp_catalog.py | 36 ++-- .../standards_engine/tools.py | 2 + .../tests/mcp_workflow_client.py | 2 +- .../tests/test_capture_handoff_transport.py | 5 +- .../tests/test_consumer_publication.py | 15 +- .../tests/test_input_discovery.py | 9 +- .../tests/test_proposal_consumers.py | 69 ++++++- .../tests/test_purpose_projection.py | 181 +++++++++++++++++- .../tests/test_purpose_transport.py | 8 +- .../standards_engine/tests/test_read_many.py | 12 +- .../tests/test_registration_contract.py | 2 +- .../tests/test_relationship_vocabulary.py | 18 +- .../tests/test_route_content.py | 111 ++++++++++- .../tests/test_routing_fact_transport.py | 24 ++- .../tests/test_runtime_identity.py | 3 +- .../tests/test_schema_presentation.py | 2 +- .../tests/test_supporting_workflow.py | 10 +- 36 files changed, 1007 insertions(+), 228 deletions(-) create mode 100644 .agents/skills/coding-standards/SKILL.md diff --git a/.agents/skills/coding-standards/SKILL.md b/.agents/skills/coding-standards/SKILL.md new file mode 100644 index 00000000..72c01adc --- /dev/null +++ b/.agents/skills/coding-standards/SKILL.md @@ -0,0 +1,143 @@ +--- +name: coding-standards +description: Obtain the engineering standards that apply to a coding task from the Standards Engine application tools. Use at the start of any task that plans, writes, changes, reviews, tests, builds, documents, commits or releases code, before planning or editing, and again when the task grows. Not for maintaining the standards themselves; that is the standards-engine authoring skill. +--- + +# Coding Standards + +The Standards Engine holds the engineering standards as modules. You state facts +about your task; it returns every module that applies, with its full text. Read +them before you plan or edit, then follow them. + +Use the application-purpose Standards Engine MCP tools. The tool-name prefix +depends on the client (for example `mcp__standards-engine__route`); the operation +names below are exact. + +## The Sequence + +1. **Get the vocabulary once.** Call `routing_facts` with no arguments. It lists + every fact: its exact name, meaning and allowed values. Keep the `snapshot` it + returns. +2. **Route.** Call `route` with that snapshot, the facts that are true of your + task, and `content: {}`. +3. **Read every page.** `reading_plan` lists every module that applies. + `content.items` holds the full text of the modules on this page. While + `content.next` is present, call `route` again with exactly the arguments in + `content.next`. +4. **Work from what you hold.** Pass the same `snapshot` in every later call. A + module you already hold at that snapshot has not changed; do not read it + again. + +## Worked Example + +Task: implement a Rust function that is called from C. + +`route` request: + +```json +{ + "snapshot": {"kind": "snapshot-handle", "id": "snapshot:v1:...", "schema_version": 5}, + "facts": { + "routing.activities": ["implementation"], + "routing.languages": ["rust"], + "routing.boundaries": ["interop"] + }, + "content": {} +} +``` + +Response outline (nine modules apply; this first page carries two of them): + +```text +kind: application-route-result +snapshot: the same handle; keep passing it +status: needs-facts +reading_plan: + core review_state: current + router review_state: current + workflow.verification review_state: current + topic.contracts review_state: current + topic.security review_state: current + profile.boundary.interop review_state: not-reviewed + profile.language.rust review_state: current + profile.language.rust.interop review_state: not-reviewed + workflow.implementation review_state: current +unresolved_questions: routing.applications, routing.details, routing.frameworks, + routing.topics, routing.workflow-profiles +content: + offset: 0 + total: 9 + items: + - policy.id: core review_state: current content: "# Core Standards ..." + - policy.id: router review_state: current content: "# Standards Router ..." + next: {snapshot, facts, content: {offset: 2, limit: 8}} +``` + +Call `route` with `content.next` exactly as given, and repeat until a page has no +`next`. All nine modules, including the two labelled `not-reviewed`, are then in +hand. + +`status: needs-facts` means some facts were not stated, so the selection may be +incomplete. Look at `unresolved_questions`: if one of those facts is true of your +task, route again with it added and the same snapshot. The modules already +returned still apply. + +## Choosing Facts + +- Supply what is true of the task. Copy names and values exactly from + `routing_facts`; a near spelling is rejected, never guessed. +- Omit what you do not know. An omitted fact stays unknown and comes back in + `unresolved_questions`. +- `[]` states that none of the values apply. Supply it only when you know that; + do not use it to silence a question. +- Do not delete a true fact to make a call succeed or to shrink the result. A + rejection tells you what to correct. Fewer facts means missing standards. +- When the task grows (another language, a new boundary), route again with the + added facts and the same snapshot. Read only the modules you do not yet hold. + +## Reading In Small Batches + +Most clients show about 50 KB of a tool result inline and divert anything larger +to a file. Route pages are sized to fit: about 40 KB each, and always at least +one whole module. Follow `content.next` until it is absent. + +Use `read` for one module by ID and `read_many` for a few. Ask `read_many` for +two or three modules per call so the whole result is shown. IDs come from a +`route`, `read` or `related` result; use them exactly. + +## Snapshot Reuse + +- Every result returns a `snapshot`. Pass it unchanged in later calls so that + everything you read comes from one version of the standards. +- Omitting `snapshot` captures the current accepted standards afresh. Do that at + the start of a new task, not in the middle of one. +- Text held at a snapshot never changes. Do not re-read it to be safe. + +## Review Labels + +Every `reading_plan` entry and every delivered module carries `review_state`. + +| Label | Meaning | +| --- | --- | +| `current` | This exact text was approved for application use. | +| `changed-since-review` | The text was edited after it was approved. | +| `not-reviewed` | The text has never been approved for application use. | + +All three are delivered and all apply to your task. The label tells you how +settled the wording is; it is not permission to skip a module. If a module's +wording is unclear, or two modules seem to disagree, tell the user which modules +and what their labels are instead of silently choosing. + +## When A Call Is Rejected + +| Code | What to do | +| --- | --- | +| `APPLICATION.INPUT_INVALID` | Correct the field named in `input_feedback`. Check fact names and values against `routing_facts`. Keep the facts that are true. | +| `APPLICATION.UNKNOWN_TARGET` | The ID is not registered. Use an ID exactly as `route`, `read` or `related` returned it. | +| `APPLICATION.UNKNOWN_GROUP`, `APPLICATION.TRAVERSAL_NOT_PERMITTED` | Use a group and direction that `relationship_groups` lists. | +| `APPLICATION.RESULT_LIMIT` | Ask for fewer modules in one call. | +| `APPLICATION.INTERNAL_UNAVAILABLE`, `APPLICATION.UNSUPPORTED_CAPTURE` | The server could not answer. Report it to the user; do not guess the standards. | + +`related` and `relationship_groups` show how modules relate when you need to +follow a prerequisite. `describe_input` shows an exact argument shape when your +client abbreviates one. diff --git a/.agents/skills/standards-engine/SKILL.md b/.agents/skills/standards-engine/SKILL.md index a072f79d..0934d18a 100644 --- a/.agents/skills/standards-engine/SKILL.md +++ b/.agents/skills/standards-engine/SKILL.md @@ -6,8 +6,8 @@ description: Maintain this repository's coding standards through an authoring-pu # Standards Engine Authoring This skill is maintenance material for standards authors. Ordinary application -agents use their application-purpose tool catalog and approved guidance, rather -than loading this authoring skill. +agents use their application-purpose tool catalog and the `coding-standards` +skill, rather than loading this authoring skill. Use the generated public Interface. The Engine is the sole writer of standards Markdown, metadata, supplementary projections, SQLite state, and local Git diff --git a/.agents/skills/standards-engine/references/authoring.md b/.agents/skills/standards-engine/references/authoring.md index d6df3f89..f1df3319 100644 --- a/.agents/skills/standards-engine/references/authoring.md +++ b/.agents/skills/standards-engine/references/authoring.md @@ -231,8 +231,10 @@ and templates support `revise-operational-artifact`. After material review, call authoring `preview_application` with the exact revision and an application read, route or related request. Inspect the complete returned -content, required closure, relationship filtering and qualification results. Repair -missing qualifications or retain authoring-only material outside application exposure. +content, selected closure, relationship filtering and each item's `review_state` +label. The preview delivers every registered item an application agent would +receive; approve or withdraw exposure to change a label, and keep authoring-only +reasoning in provenance records, which the application view never returns. Candidate previews remain bound to the revision and do not publish a snapshot. Refresh the client catalog after an engine update and inspect initialization's @@ -337,7 +339,7 @@ for the code-to-content handoff. Read operational aids to obtain their captured authoring target. Submit provenance content and an explicit exposure decision in the same coherent change as applicable; the Engine binds final candidate content. Provenance-only maintenance retains unchanged normative revisions. -Application eligibility starts empty and becomes active only after reviewed +An approval changes an item's application `review_state` label only after reviewed publication, not after merely creating a draft. diff --git a/.agents/skills/standards-engine/references/environment.md b/.agents/skills/standards-engine/references/environment.md index 9b2b9524..4995210a 100644 --- a/.agents/skills/standards-engine/references/environment.md +++ b/.agents/skills/standards-engine/references/environment.md @@ -38,6 +38,13 @@ new application session after authoring. The Engine cannot erase prior context. } ``` +Add `"--route-page-bytes", "N"` to the application arguments only when the client +shows more or less than about 50 KB of a tool result inline. The default page +budget is 40,960 bytes of result JSON, the range is 8,192–2,097,152, a page always +holds at least one whole module, and the option is a launch error for authoring. +Application agents use the `coding-standards` skill in +`.agents/skills/coding-standards/`; this authoring skill is for maintainers. + These are separate intended audiences, not two registrations every agent should receive. Translate the command, arguments and environment to the client's actual configuration format. Restart the Engine and reconnect after the interface-41 @@ -51,7 +58,7 @@ configured purpose. The local server remains synchronous MCP stdio with protocol `2025-11-25`; requests execute serially and immutable Engine handles survive reconnection. -The current implementation is 0.2.0 and Engine interface 44. No network listener, +The current implementation is 0.2.0 and Engine interface 49. No network listener, paid model turn, remote publication or extra server dependency is introduced. The existing local authoring authorization adapter is owner-operated and always-allow; explicit user authorization still governs requested changes. @@ -63,11 +70,12 @@ remote multi-user permission service. ## Bootstrap and cutover -New automatic snapshots read accepted local `main`. The code release initially -contains empty application-approval and provenance manifests. Application reads -therefore return a bounded unavailable result until the separate content work -reviews and publishes the required material. Authoring can read the unchanged -standards once the code candidate is integrated into accepted main. +New automatic snapshots read accepted local `main`. The application-approval +manifest records which exact material was reviewed for application use. Since +interface 49 it labels delivered material (`current`, `changed-since-review` or +`not-reviewed`) and never withholds it, so application reads and routes work +before, during and after the separate content review. Authoring can read the +unchanged standards once the code candidate is integrated into accepted main. Use a disposable clone with candidate `main` for pre-merge qualification. Preserve active installed proposals and recovery obligations before cutover. Old Analysis diff --git a/.agents/skills/standards-engine/references/navigation.md b/.agents/skills/standards-engine/references/navigation.md index e05bdf58..4c283677 100644 --- a/.agents/skills/standards-engine/references/navigation.md +++ b/.agents/skills/standards-engine/references/navigation.md @@ -18,7 +18,9 @@ MCP tool definitions supplied by the client; invoke the tools directly. group the selected policies into `read_many` with the returned snapshot and ordered `items` such as `[{"target":"core"}]`. Select up to 32 unique read items per call. The complete result is bounded to 2 MiB and any - unavailable item rejects the whole group; narrow the selection on a limit. + unregistered or failed item rejects the whole group; narrow the selection on a + limit. Two or three modules per call keep a result within what most clients + show inline. Grouping preserves the same exact text, authority and detail options as `read`. 5. Use returned inspect operations and handles when more detail is needed. `inspect` accepts opaque handles, not repository locators. @@ -47,16 +49,23 @@ selected, deduplicated target order. `content.total` counts all selected targets `route` request, preserving its facts and snapshot. Nonzero offsets require an explicit snapshot. Changing facts intentionally starts a different selection. -The complete route result, including its plan, questions, items and continuation, -is limited to 2 MiB. Byte pressure returns fewer whole reads. A first record that -cannot fit returns a typed limit rejection, never clipped policy text. Request a -selection-only route and explicitly `read` that target when the client can receive -it. An unavailable selected dependency or a failed read rejects the result; -partial prefixes are not returned as success. An offset equal to the selected -count returns an empty final page; a larger offset is invalid. - -All content uses the same captured authority and ordinary read/qualification -rules. Missing facts remain unresolved even when selected text is returned. +The complete authoring route result, including its plan, questions, items and +continuation, is limited to 2 MiB. Byte pressure returns fewer whole reads. A first +record that cannot fit returns a typed limit rejection, never clipped policy text. +Request a selection-only route and explicitly `read` that target when the client can +receive it. A failed read rejects the result; partial prefixes are not returned as +success. An offset equal to the selected count returns an empty final page; a +larger offset is invalid. + +Application route pages are sized for inline display instead: 40 KiB of result +JSON by default, or the application server's `--route-page-bytes` value +(8,192–2,097,152). A page always holds at least one whole read, so a module larger +than the budget arrives alone rather than as a rejection. Every selected module is +delivered with its `review_state` label (`current`, `changed-since-review` or +`not-reviewed`); approval state never withholds a selected module. + +All content uses the same captured authority and ordinary read rules. Missing +facts remain unresolved even when selected text is returned. Only selected content is paged. Compact plans contain the complete selected closure; all fact questions remain present. The full explanation additionally includes unresolved-policy rows. Content continuations preserve the requested detail. @@ -95,8 +104,8 @@ do not rebuild them from stale spellings or a different snapshot. Malformed common JSON shapes fail before capture. A vocabulary-dependent error can occur after capture when the snapshot was omitted; it returns invalid field feedback, not a successful route or authoring change. Correct the field or consult the -snapshot-bound vocabulary. Unqualified application Router content remains unavailable -before its vocabulary is interpreted or disclosed. +snapshot-bound vocabulary. Application routing interprets the vocabulary whatever +the Router's review label is. Focused authoring `route` defaults to `compact-route-result`: canonicalized supplied facts, selected reading entries and required dependencies, every typed @@ -110,7 +119,7 @@ Each unanswered question carries its registered fact definition. Supply empty sets only when the task establishes absence, rather than to silence questions. Full rule expressions describe evaluated applicability, not inferred policy prose. Required dependency reasons identify their graph edge and source. Several reasons -may select the same standard. Application purpose retains the same qualified +may select the same standard. Application purpose retains the same labelled selection and all questions even when full detail is requested; private authoring rule explanations are not exposed. @@ -127,7 +136,8 @@ traversal policy, without reading policy text merely to find a group name. Reuse its snapshot with `related`. An omitted snapshot captures accepted authority; nonzero page offsets require the returned snapshot. Pages contain up to 32 whole records (default 8), with a 16 KiB page limit; follow `next` unchanged. Application -vocabulary comes only from its permitted graph and requires qualified Router content. +vocabulary comes only from its permitted graph: every registered material, in the +five application relationship groups. An unknown focused group returns `GRAPH.UNKNOWN_GROUP` (application: `APPLICATION.UNKNOWN_GROUP`) and `relationship_groups`, the same bounded first @@ -135,7 +145,10 @@ vocabulary page. Choose a returned ID explicitly. A registered group can have no edges for the selected target; that is a successful empty query. Traversal directions and transitivity describe the group's traversal policy, not a claim of existing relationships. Authoring provenance groups are excluded from application vocabulary. -Native authoring queries and draft previews keep their existing rejection contracts. +A traversal the group does not permit returns `APPLICATION.TRAVERSAL_NOT_PERMITTED` +in application purpose; an unregistered target returns `APPLICATION.UNKNOWN_TARGET`. +Native authoring queries keep their existing rejection contracts; draft previews +return the application codes bound to their revision. ## Accepted-Snapshot Analysis @@ -172,6 +185,6 @@ instruction to infer an impact decision. Use `describe_input` for argument shapes, not policy text. It observes only the running purpose-qualified catalog and needs no snapshot. Application connections -can discover their own reviewed-guidance navigation inputs but cannot discover +can discover their own navigation inputs but cannot discover unpublished authoring operations or definitions. `route`, `read`, and `related` remain the owners of policy selection, text and relationships. diff --git a/.github/workflows/purpose-separated-engine.yml b/.github/workflows/purpose-separated-engine.yml index 02fcd779..d85bbed0 100644 --- a/.github/workflows/purpose-separated-engine.yml +++ b/.github/workflows/purpose-separated-engine.yml @@ -9,6 +9,7 @@ on: paths: - 'tools/**' - '.agents/skills/standards-engine/**' + - '.agents/skills/coding-standards/**' - 'evaluation/standards-effectiveness/**' - '*.md' - 'workflows/**' diff --git a/evaluation/standards-effectiveness/generated/suite-inputs.json b/evaluation/standards-effectiveness/generated/suite-inputs.json index 4c5c9332..93157916 100644 --- a/evaluation/standards-effectiveness/generated/suite-inputs.json +++ b/evaluation/standards-effectiveness/generated/suite-inputs.json @@ -2,7 +2,7 @@ "contract": "standards-metadata:suite-input-manifest:v1", "files": [ { - "digest": "sha256:be12934a0e6534ead4da95bef3c6af40a8062ad0352166800b10aec30c72809a", + "digest": "sha256:90dec32a6de5d9b66a8d3428f68ce957cec0a05bebc3a0006956b3ad2ad57c1d", "path": ".agents/skills/standards-engine/references/authoring.md", "state": "present", "uses": [ @@ -14,7 +14,7 @@ ] }, { - "digest": "sha256:418191d37a77028f7e287b165f9ee69eee20f8207af5a4f5ba7f792f0fcfae06", + "digest": "sha256:f87192dfc79ab5011bba220351faa1a13940a3162f812770149553acc210c437", "path": ".agents/skills/standards-engine/references/environment.md", "state": "present", "uses": [ @@ -7347,7 +7347,7 @@ ] }, { - "digest": "sha256:142cffd188781617e4641812e2f9bd33b99edf7bbbbd1d54e613bbcbcc8864a2", + "digest": "sha256:b1ccb08f602fd944b1ed342603c1b75c138de348c95927978dd55fb067c505aa", "path": "tools/standards_engine/README.md", "state": "present", "uses": [ @@ -7359,7 +7359,7 @@ ] }, { - "digest": "sha256:065f284eeee398b764c8eebf151fec59727e3b0b1dad1fea942607129a110335", + "digest": "sha256:af72d1dc44c27b6bf064f1e0b792ec0c95fd84d15334159d607e032907de39db", "path": "tools/standards_engine/contracts/README.md", "state": "present", "uses": [ @@ -7371,7 +7371,7 @@ ] }, { - "digest": "sha256:ebaa5ddf6b8a3d8e95f4b70cef4f0116eb90168656973bd56d03ab12fd8940e2", + "digest": "sha256:c90f4d0b4f9b7dcd1698460f9b20df411950dad3ae6a7403f77f94f93b69bc72", "path": "tools/standards_engine/contracts/a1-contract.schema.json", "state": "present", "uses": [ @@ -7388,7 +7388,7 @@ ] }, { - "digest": "sha256:09fea7fcd76652543bec933ee0e92e604bb42ba964ee332530783ffa641baadc", + "digest": "sha256:7b5dcba11f0b6b22bad4ace83dd28ed0d9da9be7745833264cac2ce67bb0c041", "path": "tools/standards_engine/contracts/a1-interface.toml", "state": "present", "uses": [ @@ -7405,7 +7405,7 @@ ] }, { - "digest": "sha256:146231132e8fbff19b5d917c1268bb75a0195cff4478d0e44df6bf04b8ba6aa2", + "digest": "sha256:0a9be0dced6778e95216f874654a13fdffa21ec93186077e95553e656a6531b8", "path": "tools/standards_engine/contracts/examples/a1-examples.json", "state": "present", "uses": [ @@ -7422,7 +7422,7 @@ ] }, { - "digest": "sha256:af743a7e69652d5df3a0e010068d5557393359e5e63fda9bd97711903ad4627f", + "digest": "sha256:a83afeec0e46b2f2859608bc5650392e688b3d150b9635ca0a8c9e939c830497", "path": "tools/standards_engine/contracts/generated/agent-tools.json", "state": "present", "uses": [ @@ -7485,7 +7485,7 @@ ] }, { - "digest": "sha256:5bd60e1e3d3f0796503e2f29599a4b3b7503090d86a00fa37080554b038f5958", + "digest": "sha256:3dd7f140155b28c086c870a499fb13e435975fac445daedd5fc16c9c1444a80b", "path": "tools/standards_engine/standards_engine/_generated_contract.py", "state": "present", "uses": [ @@ -7507,7 +7507,7 @@ ] }, { - "digest": "sha256:e545029d0c37b3256c810a849c6fa3af8bfe4bf11415d208c4277c7e7a26b9fe", + "digest": "sha256:63a3388f9596bde80dcebd42186c41c206e515a0b44bd2b7b11f39d6656b3716", "path": "tools/standards_engine/standards_engine/agent_navigation.py", "state": "present", "uses": [ @@ -7579,7 +7579,7 @@ ] }, { - "digest": "sha256:7d2a0b4d4c6529d403a943caf0bcd5c98e5b33ef1dc33f141679fe78b027a437", + "digest": "sha256:05ea1e614df7ac40fe17ff66d03c558412289e538b652696fd9c89fd92812755", "path": "tools/standards_engine/standards_engine/context_projection.py", "state": "present", "uses": [ @@ -7615,7 +7615,7 @@ ] }, { - "digest": "sha256:ee994e8cb911405bcb1f97508d910f906af22ce0a3040200f844ff3e52de2e2b", + "digest": "sha256:006f12dbdd8717b9069108df7b410a67c213441a1ff682dd712dcab348a708ff", "path": "tools/standards_engine/standards_engine/engine.py", "state": "present", "uses": [ @@ -7685,7 +7685,7 @@ ] }, { - "digest": "sha256:49b9ba34111d7fff7dfb575ec3e7e29d8d2be259ab35ba03bd7af26feb5b8c89", + "digest": "sha256:7554daaf2ed4ebb91dea74886448bcb34552a50a4569c4321344f36f9e5f073f", "path": "tools/standards_engine/standards_engine/mcp.py", "state": "present", "uses": [ @@ -7697,7 +7697,7 @@ ] }, { - "digest": "sha256:c6527bf9f3338e21dfd1e5e9e30933cf98c28dc6c326906892717e7c434cb74d", + "digest": "sha256:efa10c69d5cd5ada87a469f87af027dd98e61378bbfcff3767eb9600acc3d109", "path": "tools/standards_engine/standards_engine/mcp_catalog.py", "state": "present", "uses": [ @@ -7846,7 +7846,7 @@ ] }, { - "digest": "sha256:52f6762cc0c94c40df466a632cec7612eec5fa6479b486b523835cd2c2f245b2", + "digest": "sha256:7081d32b13c3e8b90e42aedb2a24e1e395b6a9380aa5448faf1314c6c2ae0015", "path": "tools/standards_engine/standards_engine/tools.py", "state": "present", "uses": [ @@ -14116,7 +14116,7 @@ "path": "evaluation/standards-effectiveness/suite-registry.toml" }, "repository_index": { - "digest": "sha256:96dd89639c5b1a45d6c6692e969cea93338efdd3e5604fb2c2d30e6cfe254fd7", + "digest": "sha256:f8a3b7983129c5f17b6d5d00e541db2ac345b90d0224338d88ccb9ab5ddfa911", "uses": [ { "check": "python-package-contract", diff --git a/tools/standards_engine/PURPOSE-SEPARATION.md b/tools/standards_engine/PURPOSE-SEPARATION.md index 02e66413..67c8ec0c 100644 --- a/tools/standards_engine/PURPOSE-SEPARATION.md +++ b/tools/standards_engine/PURPOSE-SEPARATION.md @@ -1,5 +1,76 @@ # Purpose-separated Engine contract +## Labelled application delivery (interface 49) + +Application approval is a review label, not a delivery gate. Every registered +standard and registered operational aid (prompt, template or documentation) that +an application call selects or names is delivered. `route`, `read`, `read_many`, +`related`, `relationship_groups`, `routing_facts`, `inspect`, native `query` and +authoring `preview_application` no longer depend on the approval state of the +Router, Core, the target or its prerequisites. Editing Core or the Router changes +their labels; it does not take the application interface offline. + +Each application read result (single, grouped, routed content item or candidate +preview) and each application `reading_plan` entry carries `review_state`: + +| `review_state` | Authoring `application_exposure` | Meaning | +| --- | --- | --- | +| `current` | `current` | This exact material was approved for application use. | +| `changed-since-review` | `needs-review` | The material changed after its approval. | +| `not-reviewed` | `unreviewed` | The material has never been approved. | + +A scoped policy read carries the label of its containing module. A label reports +the item's own state; prerequisites carry their own labels where they are +delivered. Labels describe editorial review of the wording, not whether guidance +applies. The approval manifest, its Engine-derived bindings, +`approve-application-content`, `withdraw-application-content`, the authoring +`application_exposure` values and the review workflow are unchanged. + +The application relationship graph contains every registered material and its +registered policy units, restricted to the `standards-requires`, +`standards-specializes`, `standards-dependencies`, `policy-impact` and `semantic` +groups. Decision provenance, the `decision-provenance` group and unregistered +consumers such as fixtures and implementation artifacts stay outside it; they can +neither be read nor connect a traversal. + +`APPLICATION.CONTENT_UNAVAILABLE` is removed; no path reports that guidance awaits +publication. Rejections name what the caller can correct: + +| Code | Outcome | Cause | +| --- | --- | --- | +| `APPLICATION.UNKNOWN_TARGET` | `invalid` | The identity or handle is not registered application material. Use an ID exactly as a route, read or related result gave it. | +| `APPLICATION.UNKNOWN_GROUP` | `invalid` | Unchanged for `related`; candidate previews now return it too. | +| `APPLICATION.TRAVERSAL_NOT_PERMITTED` | `invalid` | The selected group does not permit that direction or transitive traversal. | + +Misspelt, unknown, provenance and unregistered-consumer identities receive the +same `APPLICATION.UNKNOWN_TARGET` result, so the code does not reveal whether a +private record exists. Any other graph failure is +`APPLICATION.INTERNAL_UNAVAILABLE`. Candidate previews return the same codes and +messages bound to their revision. + +### Client-sized route content pages + +Application route content pages are sized for inline display by the client. The +page budget defaults to 40 KiB (40,960 bytes) of the result's one default JSON +serialization, which is the MCP text copy; the duplicate structured copy and +protocol framing are outside it. An application server accepts +`--route-page-bytes N` from 8,192 to 2,097,152; the option is a launch error for +authoring. Byte pressure ends a page before the next whole read, and a page always +keeps its first whole read: a module larger than the budget is returned alone, +never clipped or rejected. Only a result above the 2 MiB transport bound returns +`APPLICATION.RESULT_LIMIT`. Follow `content.next` unchanged. Authoring route +content, `read_many` in both purposes and selection-only routes keep their +existing bounds. + +Application `initialize` instructions and tool descriptions state the normal +sequence in plain language. Application agents learn the same sequence from the +[`coding-standards` skill](../../.agents/skills/coding-standards/SKILL.md). + +Interface 49 and result projection 9 version these result shapes. Request contract +6 and snapshot, Analysis, handle and store versions are unchanged, and no stored +state is migrated. Restart the MCP process and refresh the client catalog. +Sections below that describe an approval gate record earlier editions. + ## Explicit certificate retirement (interface 48) Authoring `maintain_evidence` accepts optional @@ -42,7 +113,7 @@ workflow. Canonical interface operation variants own each purpose's input and result definitions; MCP and CLI project only their reachable schema closure. The public application boundary constructs dedicated result values from -qualified domain material. Full detail remains within that boundary. Both +registered domain material. Full detail remains within that boundary. Both MCP result encodings carry the same value. Unknown/private identities and malformed requests receive bounded application outcomes. Detailed operational failures stay in host-private diagnostics, which the host must keep outside an @@ -62,9 +133,9 @@ The two support manifests are mandatory captured inputs: Both are empty in this code delivery. Existing normative and reference bytes remain unchanged and authoring-readable after the code candidate is integrated -into accepted `main`. Application reads initially report that the requested -guidance awaits application publication. This is intentional bootstrap behavior, -not an inference that legacy prose was reviewed. +into accepted `main`. Material without an approval is delivered with the +`not-reviewed` label (before interface 49 it was withheld). An empty manifest is +intentional bootstrap state, not an inference that legacy prose was reviewed. A supported snapshot contains its exact support records, exposure decisions, Router inputs and material. Reopening uses those captured bytes. Later exposure @@ -239,7 +310,7 @@ returned by routing or a single read, and select only the needed guidance. The result contains the original snapshot and ordered single-read results. One complete durable content/identity validation supplies the whole operation; current snapshot lifecycle is checked before every item and before return. -Purpose, exposure, prerequisite and item-option checks use the ordinary read +Purpose, review-label and item-option handling use the ordinary read projection. Any failed item or lifecycle observation rejects the entire set. No item content is returned on failure. A new independent call verifies durable content again. This is a new explicit operation, not a change to single reads. @@ -265,19 +336,21 @@ Operational aids bind their source content and registered policy-owner facts. The derived states are `unreviewed`, `current` and `needs-review`. Content changes preserve the old declaration as stale until explicit renewed approval or -withdrawal. An application read requires its selected unit and actual mandatory -prerequisites to be current. Unknown applicability remains a request for facts; -a missing required qualification is an explicit unavailable observation. +withdrawal. The application view delivers material in every state and reports the +state as its `review_state` label; see +[labelled application delivery](#labelled-application-delivery-interface-49). +Unknown applicability remains a request for facts. Supplementary relationships remain selective. A prompt's policy-impact association does not acquire `Requires` semantics. The application graph view -contains permitted endpoints before traversal, so hidden intermediary nodes -cannot connect otherwise disconnected visible material. Whole-module discovery +contains its permitted endpoints (registered materials and their policy units) +before traversal, so hidden intermediary nodes cannot connect otherwise +disconnected visible material. Whole-module discovery includes relationships declared by its registered policy units. -Eligibility is an editorial decision. The runtime checks the declaration, -binding and required closure; it does not classify sentiment or prove prose -quality. No positivity model or lexical prohibition list is part of the runtime. +Approval is an editorial decision. The runtime checks the declaration and +binding and reports the result as a label; it does not classify sentiment or +prove prose quality. No positivity model or lexical prohibition list is part of the runtime. ## Decision provenance @@ -414,10 +487,10 @@ identities and prior proposal records remain intact. An authoring caller uses `preview_application` with the exact draft revision and one application read, route or related request. Candidate results carry that revision, without published-snapshot or snapshot-child handles. Their -continuations remain candidate previews. The same application view enforces -qualification, prerequisite closure and graph filtering. A missing qualification -is a candidate-application rejection, not partial acceptance. Normal application -sessions retain their published-only operation set. +continuations remain candidate previews. The same application view supplies +delivery, review labels and graph filtering. An unregistered target is a +candidate-application rejection. Normal application sessions retain their +published-only operation set. `maintain_evidence` remains accepted-repository maintenance, not draft mutation. Use logical registration for draft-only scopes. After installing this change, @@ -692,17 +765,19 @@ Focused `route` optionally accepts `content` with `offset` (default 0) and `limi (default 8, 1–32). Both purposes use one captured snapshot, one compiled input and the ordinary purpose-qualified single-read owner. Content contains whole compact reads for selected unique targets, in reading-plan order. The complete composed -JSON result is limited to 2 MiB. Byte pressure ends a page before the next whole +JSON result is limited to 2 MiB; application pages additionally use the +[interface-49 page budget](#client-sized-route-content-pages). Byte pressure ends +a page before the next whole read; `content.next` is a complete route request with identical facts, snapshot, limit and the next offset. Missing applicability facts remain missing. Reading plan and unresolved questions are not paged or suppressed. Nonzero offsets require explicit snapshot authority before capture. An offset past -the selected count rejects; equality returns a final empty page. A single oversized -record or oversized route envelope yields a bounded limit rejection. The caller -may explicitly route without content, then read a target with an adequate client. -Selected dependency qualification is checked for the whole route, not only the -current page. Failed reads or lifecycle checks expose no successful partial prefix. +the selected count rejects; equality returns a final empty page. In authoring, a +single oversized record or oversized route envelope yields a bounded limit rejection; +the caller may explicitly route without content, then read a target with an adequate +client. Application routes deliver every selected target with its review label. +Failed reads or lifecycle checks expose no successful partial prefix. The existing selection-only route, native query and candidate preview contracts retain their previous behavior. This is paging over a request, not an authorization cursor: changing facts explicitly requests another route. @@ -819,7 +894,7 @@ closure. `unresolved_policy_count` counts reading-plan entries not selected; it not evidence those policies do not apply. `explanation` is a complete full-route request anchored to the same snapshot and facts. Full focused route retains `agent-route-result`; native queries and candidate previews keep prior contracts. -Application results remain qualified and never disclose private rule explanations. +Application results keep their own projection and never disclose private rule explanations. Content paging retains detail, facts and snapshot. Rule evaluation and missing vs known-empty semantics are unchanged; compact presentation does not build full rule expression output merely to discard it. @@ -828,12 +903,12 @@ expression output merely to discard it. selected graph. Its result records purpose, snapshot, total, offset, whole group items and next arguments. Each item contains id, registered meaning and traversal policy, not source locators, validator implementation or extension metadata. The -application view supplies only permitted groups after Router qualification. A group +application view supplies only permitted groups. A group can be registered with no relationships for a target. Default 8/max 32 records and 16 KiB page JSON bound the result; oversized records return unsupported without truncation. Nonzero offsets require the exact snapshot, and final lifecycle failure discards the complete page. Unknown focused `related` queries return the same first -page as optional rejection feedback (qualified targets are checked first). Native +page as optional rejection feedback (registered targets are checked first). Native application queries share that behavior; native authoring and candidate queries keep existing authority-specific failures. No guessed alias or alternate graph is used. @@ -971,10 +1046,10 @@ The bound selection helper reuses the existing algorithm and program schema-dige checks. Native query/preview callers still bind canonical typed inputs before selecting; they are not a fallback for old focused requests. -Application dispatch first qualifies Router and its required content. It then binds -focused input and qualifies the complete selected content closure before returning -a route or page. The new invalid-input adaptation is confined to that known binding -boundary, not a general change to lifecycle/qualification errors. Authoring returns +Application dispatch binds focused input and returns the complete selected content +closure with review labels (interface 49 removed the earlier Router and closure +qualification step). The invalid-input adaptation is confined to that known binding +boundary, not a general change to lifecycle errors. Authoring returns `ROUTE.INPUT_INVALID`; application returns `APPLICATION.INPUT_INVALID`. Both include bounded existing input_feedback with a route describe_input hint. Known fields may be named; unrecognized input keys/values are not echoed. This is one fixed-prose diff --git a/tools/standards_engine/README.md b/tools/standards_engine/README.md index 8b42403c..b4ae9fe4 100644 --- a/tools/standards_engine/README.md +++ b/tools/standards_engine/README.md @@ -1,10 +1,24 @@ # Standards Engine -The current interface is **48**. Input contracts are native-only; `--schema-mode` +The current interface is **49**. Input contracts are native-only; `--schema-mode` is no longer accepted. Exact input/output contracts remain available through `describe_input` and `describe_output`. Select `--output-schemas on-demand` for the smaller catalog; eager output delivery remains the default. +Interface 49 makes application approval a review label instead of a delivery gate. +An application agent receives every registered module its facts select or its call +names; each read result and reading-plan entry carries `review_state` (`current`, +`changed-since-review` or `not-reviewed`). Editing Core or the Router changes their +labels and no longer takes the application interface offline. An unregistered +identity returns `APPLICATION.UNKNOWN_TARGET`; `APPLICATION.CONTENT_UNAVAILABLE` is +removed. Application route content pages default to 40 KiB of result JSON so a +client can show them inline; `--route-page-bytes` selects 8,192–2,097,152 for an +application server, and a page always holds at least one whole module. The +approval manifest and authoring exposure workflow are unchanged. Application +agents use the [`coding-standards` skill](../../.agents/skills/coding-standards/SKILL.md). +Restart the MCP process and refresh the client catalog. See +[labelled application delivery](PURPOSE-SEPARATION.md#labelled-application-delivery-interface-49). + Interface 44 aligns logical graph, store-path, integer and evidence-digest boundaries. The Digest scalar now excludes trailing data explicitly. Operation shapes and stored workflow identities are unchanged. Restart the MCP process and refresh the client @@ -49,8 +63,8 @@ recorder. ## Purpose separation (interface 31) Version 0.2.0 / interface 31 requires host-selected `application` or `authoring` -purpose. Application views use exact reviewed content declarations; the real -corpus intentionally starts unqualified in this code release. Authoring retains +purpose. Application views label material against exact reviewed content +declarations (since interface 49 the label no longer withholds it). Authoring retains the complete workflow and adds provenance, registered operational-aid editing and explicit application exposure decisions. Analysis request 6 / state 7 bind explicit preservation or change to the actual candidate semantic revision. @@ -81,7 +95,9 @@ rows. Native `query` remains available. `read_many` reads a selected set using one explicit snapshot. It accepts 1–32 ordered unique items, applies the existing purpose-qualified single-read behavior, and returns all results or one bounded rejection. Its complete JSON domain -payload is limited to 2 MiB. See [the grouped-read contract](PURPOSE-SEPARATION.md#bounded-grouped-reads). +payload is limited to 2 MiB; application agents should request two or three +modules per call so the client can show the whole result. See +[the grouped-read contract](PURPOSE-SEPARATION.md#bounded-grouped-reads). Navigation reads immutable snapshots; proposal analysis, review, verification, and application operate on exact revision handles. Proposal creation and diff --git a/tools/standards_engine/contracts/README.md b/tools/standards_engine/contracts/README.md index 4bb13f27..76c37865 100644 --- a/tools/standards_engine/contracts/README.md +++ b/tools/standards_engine/contracts/README.md @@ -1,5 +1,14 @@ # Standards Engine Contracts +Interface 49 adds a required `review_state` (`current`, `changed-since-review` or +`not-reviewed`) to application and candidate-application read results and to +application reading-plan entries. Application approval labels delivered material +and no longer withholds it. `APPLICATION.CONTENT_UNAVAILABLE` is removed; +`APPLICATION.UNKNOWN_TARGET` and `APPLICATION.TRAVERSAL_NOT_PERMITTED` are added, +and candidate previews also return `APPLICATION.UNKNOWN_GROUP`. Result projection +advances to 9; request contract 6 and persisted state versions remain unchanged. +See [the interface-49 contract](../PURPOSE-SEPARATION.md#labelled-application-delivery-interface-49). + Interface 46 adds a durable application publication receipt and a fresh, read-only observation of the selected Git checkout to apply/recover results and workflow status. Observation failures return bounded unavailable fields without @@ -83,8 +92,8 @@ accepts a canonical registered ID or returned exact target. Fixture and source consumers do not acquire an editing capability. `preview_application` accepts an exact proposal revision and one application -read/route/related request. It applies normal exposure and prerequisite checks, -returns explicitly candidate-bound results, and provides preview-only +read/route/related request. It applies normal application delivery and review +labels, returns explicitly candidate-bound results, and provides preview-only continuations. It is absent from ordinary application catalogs. Preflight still checks structure rather than returning an application view. Preview does not certify coverage, accept review, issue exposure approval or publish the draft. diff --git a/tools/standards_engine/contracts/a1-contract.schema.json b/tools/standards_engine/contracts/a1-contract.schema.json index 16142b1c..aa75fab8 100644 --- a/tools/standards_engine/contracts/a1-contract.schema.json +++ b/tools/standards_engine/contracts/a1-contract.schema.json @@ -6948,13 +6948,14 @@ }, "code": { "enum": [ - "APPLICATION.CONTENT_UNAVAILABLE", + "APPLICATION.UNKNOWN_TARGET", "APPLICATION.INPUT_INVALID", "APPLICATION.OPERATION_UNAVAILABLE", "APPLICATION.INTERNAL_UNAVAILABLE", "APPLICATION.UNSUPPORTED_CAPTURE", "APPLICATION.RESULT_LIMIT", - "APPLICATION.UNKNOWN_GROUP" + "APPLICATION.UNKNOWN_GROUP", + "APPLICATION.TRAVERSAL_NOT_PERMITTED" ] }, "outcome": { @@ -7066,6 +7067,7 @@ "purpose", "snapshot", "policy", + "review_state", "content", "scope", "requires", @@ -7085,6 +7087,9 @@ "policy": { "$ref": "#/$defs/ApplicationPolicy" }, + "review_state": { + "$ref": "#/$defs/ApplicationReviewState" + }, "content": { "type": "string" }, @@ -7162,7 +7167,8 @@ "target", "scope", "authority", - "state" + "state", + "review_state" ], "properties": { "target": { @@ -7179,6 +7185,9 @@ }, "state": { "const": "selected" + }, + "review_state": { + "$ref": "#/$defs/ApplicationReviewState" } } }, @@ -7515,6 +7524,14 @@ "needs-review" ] }, + "ApplicationReviewState": { + "enum": [ + "current", + "changed-since-review", + "not-reviewed" + ], + "description": "Review label of delivered application material. current: this exact text was approved for application use. changed-since-review: the text was edited after its approval. not-reviewed: the text has never been approved. The label never withholds material; a scoped policy read carries the label of its containing module." + }, "ProvenanceReadResult": { "type": "object", "additionalProperties": false, @@ -7961,7 +7978,7 @@ "$ref": "#/$defs/ApplicationQueryRequest" } }, - "description": "Authoring-only inspection of an exact draft through application qualification and filtering; this observation neither publishes nor grants ordinary application access." + "description": "Authoring-only inspection of an exact draft as an application agent would receive it, including each item's review label; this observation neither publishes nor grants ordinary application access." }, "CandidateApplicationNextOperation": { "type": "object", @@ -8059,6 +8076,7 @@ "kind", "purpose", "policy", + "review_state", "content", "scope", "requires", @@ -8076,6 +8094,9 @@ "policy": { "$ref": "#/$defs/CandidateApplicationPolicy" }, + "review_state": { + "$ref": "#/$defs/ApplicationReviewState" + }, "content": { "type": "string" }, @@ -8218,12 +8239,14 @@ }, "code": { "enum": [ - "APPLICATION.CONTENT_UNAVAILABLE", + "APPLICATION.UNKNOWN_TARGET", "APPLICATION.INPUT_INVALID", "APPLICATION.OPERATION_UNAVAILABLE", "APPLICATION.INTERNAL_UNAVAILABLE", "APPLICATION.UNSUPPORTED_CAPTURE", - "APPLICATION.RESULT_LIMIT" + "APPLICATION.RESULT_LIMIT", + "APPLICATION.UNKNOWN_GROUP", + "APPLICATION.TRAVERSAL_NOT_PERMITTED" ] }, "outcome": { @@ -9520,7 +9543,7 @@ } }, "additionalProperties": false, - "description": "Exact compact reads of selected targets in Router order. Total counts selected targets, not unresolved applicability. Follow next unchanged for the remaining page." + "description": "Exact compact reads of selected targets in Router order, each with its review label. Total counts selected targets, not unresolved applicability. A page ends early at the host's page byte budget but holds at least one whole item while targets remain. Follow next unchanged for the remaining page." }, "DescribeInputCall": { "type": "object", diff --git a/tools/standards_engine/contracts/a1-interface.toml b/tools/standards_engine/contracts/a1-interface.toml index a7be0562..b2df6186 100644 --- a/tools/standards_engine/contracts/a1-interface.toml +++ b/tools/standards_engine/contracts/a1-interface.toml @@ -1,7 +1,7 @@ schema_version = 1 -interface_schema_version = 48 +interface_schema_version = 49 request_contract_version = 6 -result_projection_version = 8 +result_projection_version = 9 [[operations]] id = "create_snapshot" diff --git a/tools/standards_engine/contracts/examples/a1-examples.json b/tools/standards_engine/contracts/examples/a1-examples.json index 1f256f60..b1bcc4e9 100644 --- a/tools/standards_engine/contracts/examples/a1-examples.json +++ b/tools/standards_engine/contracts/examples/a1-examples.json @@ -1,6 +1,6 @@ { "schema_version": 2, - "interface_schema_version": 48, + "interface_schema_version": 49, "examples": [ { "name": "create-snapshot", @@ -1274,7 +1274,7 @@ "value": { "kind": "input-contract-result", "purpose": "application", - "interface_version": 48, + "interface_version": 49, "catalog_digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "operation": "runtime_info", "root": "RuntimeInfoCall", @@ -1420,7 +1420,7 @@ "value": { "kind": "output-contract-result", "purpose": "authoring", - "interface_version": 48, + "interface_version": 49, "catalog_digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "operation": "review", "dialect": "https://json-schema.org/draft/2020-12/schema", diff --git a/tools/standards_engine/contracts/generated/agent-tools.json b/tools/standards_engine/contracts/generated/agent-tools.json index 9afcb2c1..858e16d3 100644 --- a/tools/standards_engine/contracts/generated/agent-tools.json +++ b/tools/standards_engine/contracts/generated/agent-tools.json @@ -1558,6 +1558,9 @@ }, "type": "array" }, + "review_state": { + "$ref": "#/$defs/ApplicationReviewState" + }, "scope": { "$ref": "#/$defs/ReviewScope" }, @@ -1576,6 +1579,7 @@ "purpose", "snapshot", "policy", + "review_state", "content", "scope", "requires", @@ -1593,6 +1597,9 @@ "contextual" ] }, + "review_state": { + "$ref": "#/$defs/ApplicationReviewState" + }, "scope": { "$ref": "#/$defs/ReviewScope" }, @@ -1607,7 +1614,8 @@ "target", "scope", "authority", - "state" + "state", + "review_state" ], "type": "object" }, @@ -1670,13 +1678,14 @@ "properties": { "code": { "enum": [ - "APPLICATION.CONTENT_UNAVAILABLE", + "APPLICATION.UNKNOWN_TARGET", "APPLICATION.INPUT_INVALID", "APPLICATION.OPERATION_UNAVAILABLE", "APPLICATION.INTERNAL_UNAVAILABLE", "APPLICATION.UNSUPPORTED_CAPTURE", "APPLICATION.RESULT_LIMIT", - "APPLICATION.UNKNOWN_GROUP" + "APPLICATION.UNKNOWN_GROUP", + "APPLICATION.TRAVERSAL_NOT_PERMITTED" ] }, "input_feedback": { @@ -1794,6 +1803,14 @@ ], "type": "object" }, + "ApplicationReviewState": { + "description": "Review label of delivered application material. current: this exact text was approved for application use. changed-since-review: the text was edited after its approval. not-reviewed: the text has never been approved. The label never withholds material; a scoped policy read carries the label of its containing module.", + "enum": [ + "current", + "changed-since-review", + "not-reviewed" + ] + }, "ApplicationRouteResult": { "additionalProperties": false, "properties": { @@ -1847,7 +1864,7 @@ }, "ApplicationRoutedContentPage": { "additionalProperties": false, - "description": "Exact compact reads of selected targets in Router order. Total counts selected targets, not unresolved applicability. Follow next unchanged for the remaining page.", + "description": "Exact compact reads of selected targets in Router order, each with its review label. Total counts selected targets, not unresolved applicability. A page ends early at the host's page byte budget but holds at least one whole item while targets remain. Follow next unchanged for the remaining page.", "properties": { "items": { "items": { @@ -2361,6 +2378,9 @@ }, "type": "array" }, + "review_state": { + "$ref": "#/$defs/ApplicationReviewState" + }, "revision": { "$ref": "#/$defs/ProposalRevisionHandle" }, @@ -2378,6 +2398,7 @@ "kind", "purpose", "policy", + "review_state", "content", "scope", "requires", @@ -2392,12 +2413,14 @@ "properties": { "code": { "enum": [ - "APPLICATION.CONTENT_UNAVAILABLE", + "APPLICATION.UNKNOWN_TARGET", "APPLICATION.INPUT_INVALID", "APPLICATION.OPERATION_UNAVAILABLE", "APPLICATION.INTERNAL_UNAVAILABLE", "APPLICATION.UNSUPPORTED_CAPTURE", - "APPLICATION.RESULT_LIMIT" + "APPLICATION.RESULT_LIMIT", + "APPLICATION.UNKNOWN_GROUP", + "APPLICATION.TRAVERSAL_NOT_PERMITTED" ] }, "kind": { @@ -6040,7 +6063,7 @@ }, "PreviewApplicationCall": { "additionalProperties": false, - "description": "Authoring-only inspection of an exact draft through application qualification and filtering; this observation neither publishes nor grants ordinary application access.", + "description": "Authoring-only inspection of an exact draft as an application agent would receive it, including each item's review label; this observation neither publishes nor grants ordinary application access.", "properties": { "request": { "$ref": "#/$defs/ApplicationQueryRequest" @@ -9966,7 +9989,7 @@ "type": "object" } }, - "interface_schema_version": 48, + "interface_schema_version": 49, "operations": [ { "capability": "standards.snapshot.create", @@ -10670,6 +10693,6 @@ } ], "request_contract_version": 6, - "result_projection_version": 8, + "result_projection_version": 9, "schema_version": 1 } diff --git a/tools/standards_engine/standards_engine/_generated_contract.py b/tools/standards_engine/standards_engine/_generated_contract.py index d35d0480..aa630834 100644 --- a/tools/standards_engine/standards_engine/_generated_contract.py +++ b/tools/standards_engine/standards_engine/_generated_contract.py @@ -14,8 +14,8 @@ model_as_contract, ) -_SCHEMA = json.loads('{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://coding-standards.local/contracts/standards-engine/a2-v40","title":"Standards Engine A2 contract","description":"Canonical typed contract for snapshot lifecycle, controlled authoring, navigation, inspection, and immutable standards-change analysis.","oneOf":[{"$ref":"#/$defs/AgentProposeCall"},{"$ref":"#/$defs/AgentResolveManyCall"},{"$ref":"#/$defs/AgentResolveWorkflowCall"},{"$ref":"#/$defs/AgentReviewCall"},{"$ref":"#/$defs/AgentReviseCall"},{"$ref":"#/$defs/AgentRouteResult"},{"$ref":"#/$defs/AnalyzeCall"},{"$ref":"#/$defs/AnalyzeProposalCall"},{"$ref":"#/$defs/ApplicationInspectCall"},{"$ref":"#/$defs/ApplicationQueryCall"},{"$ref":"#/$defs/ApplicationReadCall"},{"$ref":"#/$defs/ApplicationReadManyCall"},{"$ref":"#/$defs/ApplicationReadManyResult"},{"$ref":"#/$defs/ApplicationReadResult"},{"$ref":"#/$defs/ApplicationRecoveryRequiredResult"},{"$ref":"#/$defs/ApplicationRejectedResult"},{"$ref":"#/$defs/ApplicationRelatedResult"},{"$ref":"#/$defs/ApplicationRouteResult"},{"$ref":"#/$defs/ApplicationRoutingFactsResult"},{"$ref":"#/$defs/ApplyCall"},{"$ref":"#/$defs/ApplyProposalCall"},{"$ref":"#/$defs/ApplyProposalResult"},{"$ref":"#/$defs/CompactReadResult"},{"$ref":"#/$defs/CompactRouteResult"},{"$ref":"#/$defs/CompleteResult"},{"$ref":"#/$defs/CreateProposalCall"},{"$ref":"#/$defs/CreateProposalResult"},{"$ref":"#/$defs/CreateSnapshotCall"},{"$ref":"#/$defs/CreateSnapshotResult"},{"$ref":"#/$defs/DeleteSnapshotCall"},{"$ref":"#/$defs/DeleteSnapshotResult"},{"$ref":"#/$defs/DescribeInputCall"},{"$ref":"#/$defs/DescribeOutputCall"},{"$ref":"#/$defs/FindProposalsCall"},{"$ref":"#/$defs/FindProposalsResult"},{"$ref":"#/$defs/FindSnapshotsCall"},{"$ref":"#/$defs/FindSnapshotsResult"},{"$ref":"#/$defs/InputContractRejectedResult"},{"$ref":"#/$defs/InputContractResult"},{"$ref":"#/$defs/InspectCall"},{"$ref":"#/$defs/InspectionResult"},{"$ref":"#/$defs/MaintainEvidenceCall"},{"$ref":"#/$defs/MaintainEvidenceResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/OperationalReadResult"},{"$ref":"#/$defs/OutputContractRejectedResult"},{"$ref":"#/$defs/OutputContractResult"},{"$ref":"#/$defs/PendingResult"},{"$ref":"#/$defs/PrepareCall"},{"$ref":"#/$defs/PreviewApplicationCall"},{"$ref":"#/$defs/PreviewApplicationResult"},{"$ref":"#/$defs/ProposeCall"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/QueryCall"},{"$ref":"#/$defs/QueryProposalCall"},{"$ref":"#/$defs/QueryProposalResult"},{"$ref":"#/$defs/QueryResult"},{"$ref":"#/$defs/ReadCall"},{"$ref":"#/$defs/ReadManyCall"},{"$ref":"#/$defs/ReadManyResult"},{"$ref":"#/$defs/ReadResult"},{"$ref":"#/$defs/RecoverApplicationCall"},{"$ref":"#/$defs/RecoverApplicationResult"},{"$ref":"#/$defs/RecoverCall"},{"$ref":"#/$defs/RejectedResult"},{"$ref":"#/$defs/RelatedCall"},{"$ref":"#/$defs/RelatedResult"},{"$ref":"#/$defs/RelationshipGroupsCall"},{"$ref":"#/$defs/RelationshipGroupsResult"},{"$ref":"#/$defs/ResolveCall"},{"$ref":"#/$defs/ResolveManyCall"},{"$ref":"#/$defs/ResolveWorkflowCall"},{"$ref":"#/$defs/ResumeCall"},{"$ref":"#/$defs/ReviewCall"},{"$ref":"#/$defs/ReviewProposalCall"},{"$ref":"#/$defs/ReviewProposalResult"},{"$ref":"#/$defs/ReviseCall"},{"$ref":"#/$defs/ReviseProposalCall"},{"$ref":"#/$defs/ReviseProposalResult"},{"$ref":"#/$defs/RouteCall"},{"$ref":"#/$defs/RoutingFactsCall"},{"$ref":"#/$defs/RoutingFactsResult"},{"$ref":"#/$defs/RuntimeInfoCall"},{"$ref":"#/$defs/RuntimeInfoResult"},{"$ref":"#/$defs/UndeleteSnapshotCall"},{"$ref":"#/$defs/UndeleteSnapshotResult"},{"$ref":"#/$defs/VerifyProposalCall"},{"$ref":"#/$defs/VerifyProposalResult"},{"$ref":"#/$defs/VerifyRepositoryCall"},{"$ref":"#/$defs/VerifyRepositoryResult"},{"$ref":"#/$defs/WorkflowDetailsCall"},{"$ref":"#/$defs/WorkflowDetailsResult"},{"$ref":"#/$defs/WorkflowResult"},{"$ref":"#/$defs/WorkflowStatusCall"}],"$defs":{"NonEmptyString":{"type":"string","minLength":1},"CanonicalId":{"type":"string","pattern":"^[A-Za-z0-9][A-Za-z0-9._:/-]*$"},"EdgeId":{"type":"string","minLength":1},"Digest":{"type":"string","pattern":"^sha256:[0-9a-f]{64}$","maxLength":71},"GitObjectId":{"oneOf":[{"type":"string","pattern":"^[0-9a-f]{40}$"},{"type":"string","pattern":"^[0-9a-f]{64}$"}]},"ObligationId":{"type":"string","pattern":"^obligation:sha256:[0-9a-f]{64}$"},"ImpactTraceId":{"type":"string","pattern":"^impact-trace:sha256:[0-9a-f]{64}$"},"FactRequirementId":{"type":"string","pattern":"^fact-requirement:sha256:[0-9a-f]{64}$"},"ScalarValue":{"oneOf":[{"type":"boolean"},{"type":"integer"},{"type":"string"},{"type":"null"}]},"FactValue":{"oneOf":[{"type":"object","required":["type","state","value"],"properties":{"type":{"const":"boolean"},"state":{"const":"known"},"value":{"type":"boolean"}},"additionalProperties":false},{"type":"object","required":["type","state","value"],"properties":{"type":{"enum":["boolean","enum","string","string-set","enum-set","canonical-id"]},"state":{"const":"known"},"value":{"type":"null"}},"additionalProperties":false},{"type":"object","required":["type","state","value"],"properties":{"type":{"enum":["enum","string","canonical-id"]},"state":{"const":"known"},"value":{"type":"string"}},"additionalProperties":false},{"type":"object","required":["type","state","value"],"properties":{"type":{"enum":["string-set","enum-set"]},"state":{"const":"known"},"value":{"type":"array","items":{"type":"string"},"uniqueItems":true}},"additionalProperties":false},{"type":"object","required":["type","state"],"properties":{"type":{"enum":["boolean","enum","string","string-set","enum-set","canonical-id"]},"state":{"enum":["known-absent","unknown"]}},"additionalProperties":false}]},"FactSet":{"type":"object","additionalProperties":{"$ref":"#/$defs/FactValue"}},"StructuredScope":{"type":"object","required":["kind","heading_path"],"properties":{"kind":{"const":"structured"},"heading_path":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/NonEmptyString"}}},"additionalProperties":false},"WholeArtifactScope":{"type":"object","required":["kind"],"properties":{"kind":{"const":"whole-artifact"}},"additionalProperties":false},"ReviewScope":{"oneOf":[{"$ref":"#/$defs/StructuredScope"},{"$ref":"#/$defs/WholeArtifactScope"}]},"AllExpression":{"type":"object","required":["operator","expressions"],"properties":{"operator":{"const":"all"},"expressions":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/ApplicabilityExpression"}}},"additionalProperties":false},"AnyExpression":{"type":"object","required":["operator","expressions"],"properties":{"operator":{"const":"any"},"expressions":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/ApplicabilityExpression"}}},"additionalProperties":false},"NotExpression":{"type":"object","required":["operator","expression"],"properties":{"operator":{"const":"not"},"expression":{"$ref":"#/$defs/ApplicabilityExpression"}},"additionalProperties":false},"EqualsExpression":{"type":"object","required":["operator","fact","value"],"properties":{"operator":{"const":"equals"},"fact":{"$ref":"#/$defs/CanonicalId"},"value":{"$ref":"#/$defs/ScalarValue"}},"additionalProperties":false},"InExpression":{"type":"object","required":["operator","fact","values"],"properties":{"operator":{"const":"in"},"fact":{"$ref":"#/$defs/CanonicalId"},"values":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/ScalarValue"}}},"additionalProperties":false},"ContainsExpression":{"type":"object","required":["operator","fact","value"],"properties":{"operator":{"const":"contains"},"fact":{"$ref":"#/$defs/CanonicalId"},"value":{"$ref":"#/$defs/ScalarValue"}},"additionalProperties":false},"ExistsExpression":{"type":"object","required":["operator","fact"],"properties":{"operator":{"const":"exists"},"fact":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"AlwaysExpression":{"type":"object","required":["operator"],"properties":{"operator":{"const":"always"}},"additionalProperties":false},"ApplicabilityExpression":{"oneOf":[{"$ref":"#/$defs/AlwaysExpression"},{"$ref":"#/$defs/AllExpression"},{"$ref":"#/$defs/AnyExpression"},{"$ref":"#/$defs/NotExpression"},{"$ref":"#/$defs/EqualsExpression"},{"$ref":"#/$defs/InExpression"},{"$ref":"#/$defs/ContainsExpression"},{"$ref":"#/$defs/ExistsExpression"}]},"GeneralSelectionReason":{"type":"object","required":["kind"],"properties":{"kind":{"enum":["routing-fact","requires","specializes","changed-policy","question","audit-coverage","unmapped-normative-change","structured-scope-analysis-unsupported","navigation-index-change","supporting-content-change"]},"source":{"$ref":"#/$defs/CanonicalId"},"fact":{"$ref":"#/$defs/CanonicalId"},"edge":{"$ref":"#/$defs/EdgeId"},"question":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"PolicyImpactSelectionReason":{"type":"object","required":["kind","source","edge","relation","evidence_owner","traces"],"properties":{"kind":{"const":"policy-impact-edge"},"source":{"$ref":"#/$defs/CanonicalId"},"edge":{"$ref":"#/$defs/EdgeId"},"relation":{"$ref":"#/$defs/CanonicalId"},"evidence_owner":{"$ref":"#/$defs/CanonicalId"},"traces":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/ImpactTraceReference"}}},"additionalProperties":false},"SelectionReason":{"oneOf":[{"$ref":"#/$defs/GeneralSelectionReason"},{"$ref":"#/$defs/PolicyImpactSelectionReason"}]},"ImpactTraceReference":{"type":"object","required":["id","graph","applicability"],"properties":{"id":{"$ref":"#/$defs/ImpactTraceId"},"graph":{"enum":["accepted","proposed"]},"applicability":{"enum":["true","false","unknown"]}},"additionalProperties":false},"ConsumerReviewObligationReadingReason":{"type":"object","required":["kind","obligation"],"properties":{"kind":{"const":"consumer-review-obligation"},"obligation":{"$ref":"#/$defs/ObligationId"}},"additionalProperties":false},"RoutingBaseReadingReason":{"type":"object","required":["kind","projection"],"properties":{"kind":{"const":"routing-base"},"projection":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"RoutingRuleReadingReason":{"type":"object","required":["kind","rule","facts"],"properties":{"kind":{"const":"routing-rule"},"rule":{"$ref":"#/$defs/CanonicalId"},"facts":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"RequiresReadingReason":{"type":"object","required":["kind","edge","source"],"properties":{"kind":{"const":"requires"},"edge":{"$ref":"#/$defs/EdgeId"},"source":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"SpecializesReadingReason":{"type":"object","required":["kind","edge","source"],"properties":{"kind":{"const":"specializes"},"edge":{"$ref":"#/$defs/EdgeId"},"source":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"ReadingPlanReason":{"oneOf":[{"$ref":"#/$defs/ConsumerReviewObligationReadingReason"},{"$ref":"#/$defs/RoutingBaseReadingReason"},{"$ref":"#/$defs/RoutingRuleReadingReason"},{"$ref":"#/$defs/RequiresReadingReason"},{"$ref":"#/$defs/SpecializesReadingReason"}]},"ReadingPlanEntry":{"type":"object","required":["target","scope","authority","reasons","state"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"scope":{"$ref":"#/$defs/ReviewScope"},"authority":{"enum":["normative","projection","contextual","evidence"]},"reasons":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/ReadingPlanReason"}},"state":{"enum":["selected","conditional","unresolved"]}},"additionalProperties":false},"RouteRequest":{"type":"object","required":["kind","facts"],"properties":{"kind":{"const":"route"},"facts":{"$ref":"#/$defs/FactSet"}},"additionalProperties":false},"ReadRequest":{"type":"object","required":["kind","target"],"properties":{"kind":{"const":"read"},"target":{"$ref":"#/$defs/CanonicalId"},"include_routing":{"type":"boolean"},"include_coverage":{"type":"boolean","description":"Include current repository attestation status for registered policy units in this read scope."}},"additionalProperties":false},"RelatedRequest":{"type":"object","required":["kind","target","groups","direction","transitive"],"properties":{"kind":{"const":"related"},"target":{"$ref":"#/$defs/CanonicalId"},"groups":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"direction":{"enum":["incoming","outgoing","both"]},"transitive":{"type":"boolean","default":false}},"additionalProperties":false},"QueryRequest":{"oneOf":[{"$ref":"#/$defs/RouteRequest"},{"$ref":"#/$defs/ReadRequest"},{"$ref":"#/$defs/RelatedRequest"}]},"PolicyUnitDeclaration":{"type":"object","required":["kind","id","module","heading_path","semantic_revision","lifecycle"],"properties":{"kind":{"const":"policy-unit"},"id":{"$ref":"#/$defs/CanonicalId"},"module":{"$ref":"#/$defs/CanonicalId"},"heading_path":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/NonEmptyString"}},"semantic_revision":{"type":"integer","minimum":1},"lifecycle":{"const":"active"},"aliases":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"predecessors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"CanonicalModuleDeclaration":{"type":"object","required":["kind","id","role","level","applies_when","does_not_apply_when","requires","specializes","verification"],"properties":{"kind":{"const":"canonical-module"},"id":{"$ref":"#/$defs/CanonicalId"},"role":{"enum":["core","router","workflow","profile","topic","reference"]},"level":{"enum":["MUST","SHOULD","PROFILE","REFERENCE"]},"applies_when":{"$ref":"#/$defs/NonEmptyString"},"does_not_apply_when":{"$ref":"#/$defs/NonEmptyString"},"requires":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"verification":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PolicyRelationshipInspection":{"type":"object","required":["relationship_kind","applicability","source_scope","consumer_scope","propagation","evidence_owner","rationale"],"properties":{"relationship_kind":{"enum":["normative-consumer","router-projection","prompt-projection","template-projection","reference-projection","fixture-projection","enforcement-suite-projection","documentation-projection","implementation-projection"]},"applicability":{"$ref":"#/$defs/ApplicabilityExpression"},"source_scope":{"oneOf":[{"$ref":"#/$defs/ReviewScope"},{"type":"null"}]},"consumer_scope":{"oneOf":[{"$ref":"#/$defs/ReviewScope"},{"type":"null"}]},"propagation":{"const":"source-to-consumer"},"evidence_owner":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"SemanticProposal":{"type":"object","required":["policy","accepted_semantic_revision","proposed_semantic_revision","intent","structural_digest"],"properties":{"policy":{"$ref":"#/$defs/CanonicalId"},"accepted_semantic_revision":{"oneOf":[{"type":"integer","minimum":1},{"type":"null"}]},"proposed_semantic_revision":{"type":"integer","minimum":1},"intent":{"$ref":"#/$defs/NonEmptyString"},"structural_digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"ChangeDescriptor":{"type":"object","required":["kind","accepted_ids","proposed_ids","scope"],"properties":{"kind":{"enum":["module","modification","addition","removal","move","split","merge","navigation-index","supporting-content"]},"accepted_ids":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"proposed_ids":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"scope":{"$ref":"#/$defs/ReviewScope"},"accepted_module":{"$ref":"#/$defs/CanonicalId"},"proposed_module":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"ChangedPolicyUnit":{"type":"object","required":["policy","change_kind","classification","accepted_representation_digest","proposed_representation_digest","accepted_structural_digest","proposed_structural_digest","accepted_semantic_revision","proposed_semantic_revision","semantic_state","scope"],"properties":{"policy":{"$ref":"#/$defs/CanonicalId"},"change_kind":{"enum":["modification","addition","removal","move","split-predecessor","split-successor","merge-predecessor","merge-successor"]},"classification":{"enum":["unchanged","representation-only-candidate","possibly-semantically-changed","semantically-changed","unresolved"]},"accepted_representation_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"proposed_representation_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"accepted_structural_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"proposed_structural_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"accepted_semantic_revision":{"oneOf":[{"type":"integer","minimum":1},{"type":"null"}]},"proposed_semantic_revision":{"oneOf":[{"type":"integer","minimum":1},{"type":"null"}]},"semantic_state":{"enum":["accepted-unchanged","proposed","removed","unresolved"]},"scope":{"$ref":"#/$defs/ReviewScope"}},"additionalProperties":false},"Question":{"type":"object","required":["id","kind","prompt","state","permitted_answers"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"kind":{"enum":["applicability-fact","normative-classification","identity-resolution","scope-resolution"]},"prompt":{"$ref":"#/$defs/NonEmptyString"},"state":{"enum":["required","answered","blocked"]},"permitted_answers":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/NonEmptyString"}}},"additionalProperties":false},"ConsumerReviewContract":{"type":"object","required":["kind","id","version","permitted_dispositions","evidence_contract","authorization_capability","semantics"],"properties":{"kind":{"const":"consumer-review-contract"},"id":{"$ref":"#/$defs/CanonicalId"},"version":{"type":"integer","minimum":1},"permitted_dispositions":{"type":"array","minItems":1,"uniqueItems":true,"items":{"enum":["updated","reviewed-no-change","not-applicable","blocked"]}},"evidence_contract":{"$ref":"#/$defs/CanonicalId"},"authorization_capability":{"$ref":"#/$defs/CanonicalId"},"semantics":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"DecisionDependency":{"type":"object","required":["class","identity","digest"],"properties":{"class":{"enum":["policy-unit","semantic-revision","structure","representation","module-locator","applicability-fact","relationship","audit","exception","evidence","provider-contract","applicability-contract","analysis-contract"]},"identity":{"$ref":"#/$defs/NonEmptyString"},"digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"DecisionFingerprint":{"type":"object","required":["decision_kind","decision_contract","schema_version","dependencies"],"properties":{"decision_kind":{"$ref":"#/$defs/CanonicalId"},"decision_contract":{"$ref":"#/$defs/CanonicalId"},"schema_version":{"const":1},"dependencies":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/DecisionDependency"}}},"additionalProperties":false},"FactValueContract":{"type":"object","required":["type","states","nullable"],"properties":{"type":{"enum":["boolean","enum","string","string-set","enum-set","canonical-id"]},"states":{"const":["known","known-absent"]},"nullable":{"type":"boolean"},"values":{"type":"array","minItems":1,"uniqueItems":true,"items":{"type":"string"}}},"additionalProperties":false},"EvidenceReference":{"type":"object","required":["id","digest","provider_contract","provider_contract_version"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"digest":{"$ref":"#/$defs/Digest"},"provider_contract":{"$ref":"#/$defs/CanonicalId"},"provider_contract_version":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"CompletionProof":{"type":"object","required":["required_coverage_subjects","certificate_subjects","reached_consumer_obligations","disposition_obligations","required_fact_requirements","observed_fact_requirements","non_consumer_obligations_resolved","applicability_resolved","authorization_valid","evidence_valid"],"properties":{"required_coverage_subjects":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"certificate_subjects":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"reached_consumer_obligations":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/ObligationId"}},"disposition_obligations":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/ObligationId"}},"required_fact_requirements":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/FactRequirementId"}},"observed_fact_requirements":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/FactRequirementId"}},"non_consumer_obligations_resolved":{"const":true},"applicability_resolved":{"const":true},"authorization_valid":{"const":true},"evidence_valid":{"const":true}},"additionalProperties":false},"Timestamp":{"type":"integer","minimum":0},"SnapshotId":{"type":"string","pattern":"^snapshot:v1:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"},"AnalysisId":{"type":"string","pattern":"^analysis:sha256:[0-9a-f]{64}$"},"ProposalId":{"type":"string","pattern":"^proposal:v1:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"},"ProposalRevisionId":{"type":"string","pattern":"^proposal-revision:sha256:[0-9a-f]{64}$"},"ReadinessId":{"type":"string","pattern":"^readiness:sha256:[0-9a-f]{64}$"},"ApplicationId":{"type":"string","pattern":"^application:sha256:[0-9a-f]{64}$"},"ChildId":{"type":"string","pattern":"^sha256:[0-9a-f]{64}$"},"AuthorizationId":{"type":"string","pattern":"^authorization:sha256:[0-9a-f]{64}$"},"SnapshotHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"snapshot-handle"},"id":{"$ref":"#/$defs/SnapshotId"},"schema_version":{"const":5}},"additionalProperties":false},"AnalysisHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"analysis-handle"},"id":{"$ref":"#/$defs/AnalysisId"},"schema_version":{"const":7}},"additionalProperties":false},"ProposalHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"proposal-handle"},"id":{"$ref":"#/$defs/ProposalId"},"schema_version":{"const":1}},"additionalProperties":false},"ProposalRevisionHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"proposal-revision-handle"},"id":{"$ref":"#/$defs/ProposalRevisionId"},"schema_version":{"const":1}},"additionalProperties":false},"ReadinessHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"readiness-handle"},"id":{"$ref":"#/$defs/ReadinessId"},"schema_version":{"const":1}},"additionalProperties":false},"ApplicationHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"application-handle"},"id":{"$ref":"#/$defs/ApplicationId"},"schema_version":{"const":1}},"additionalProperties":false},"SnapshotChildHandle":{"type":"object","required":["kind","snapshot","child_kind","child_id","schema_version"],"properties":{"kind":{"const":"snapshot-child-handle"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"child_kind":{"enum":["policy","relationship"]},"child_id":{"$ref":"#/$defs/NonEmptyString"},"schema_version":{"const":5}},"additionalProperties":false},"AnalysisChildHandle":{"type":"object","required":["kind","analysis","child_kind","child_id","schema_version"],"properties":{"kind":{"const":"analysis-child-handle"},"analysis":{"$ref":"#/$defs/AnalysisHandle"},"child_kind":{"enum":["context","fact-requirement","fact-observation","obligation","coverage-requirement","coverage-certificate"]},"child_id":{"$ref":"#/$defs/ChildId"},"schema_version":{"const":7}},"additionalProperties":false},"AnalysisMaterialHandle":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/ProposalRevisionHandle"}]},"InspectableHandle":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/AnalysisHandle"},{"$ref":"#/$defs/SnapshotChildHandle"},{"$ref":"#/$defs/AnalysisChildHandle"}]},"ActiveSnapshotSummary":{"type":"object","required":["snapshot","lifecycle","source_revision","created_at"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"lifecycle":{"const":"active"},"source_revision":{"$ref":"#/$defs/NonEmptyString"},"created_at":{"$ref":"#/$defs/Timestamp"}},"additionalProperties":false},"QuarantinedSnapshotSummary":{"type":"object","required":["snapshot","lifecycle","source_revision","created_at","purge_deadline"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"lifecycle":{"const":"quarantined"},"source_revision":{"$ref":"#/$defs/NonEmptyString"},"created_at":{"$ref":"#/$defs/Timestamp"},"purge_deadline":{"$ref":"#/$defs/Timestamp"}},"additionalProperties":false},"SnapshotSummary":{"oneOf":[{"$ref":"#/$defs/ActiveSnapshotSummary"},{"$ref":"#/$defs/QuarantinedSnapshotSummary"}]},"CreateSnapshotCall":{"type":"object","required":["kind"],"properties":{"kind":{"const":"create-snapshot"}},"additionalProperties":false},"CreateSnapshotResult":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"create-snapshot-result"},"snapshot":{"$ref":"#/$defs/ActiveSnapshotSummary"}},"additionalProperties":false},"FindSnapshotsCall":{"type":"object","required":["kind"],"properties":{"kind":{"const":"find-snapshots"},"lifecycle":{"enum":["active","quarantined"],"default":"active"},"after":{"$ref":"#/$defs/SnapshotHandle"},"limit":{"type":"integer","minimum":1,"default":50}},"additionalProperties":false},"FindSnapshotsResult":{"type":"object","required":["kind","snapshots"],"properties":{"kind":{"const":"find-snapshots-result"},"snapshots":{"type":"array","items":{"$ref":"#/$defs/SnapshotSummary"}},"continuation":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"StandardsChangePurpose":{"type":"object","required":["summary","rationale","evidence"],"properties":{"summary":{"$ref":"#/$defs/NonEmptyString"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"StandardContent":{"type":"object","required":["id","title","role","level","applies_when","does_not_apply_when","verification","body"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"title":{"$ref":"#/$defs/NonEmptyString"},"role":{"enum":["core","router","workflow","profile","topic","reference"]},"level":{"enum":["MUST","SHOULD","PROFILE","REFERENCE"]},"applies_when":{"$ref":"#/$defs/NonEmptyString"},"does_not_apply_when":{"$ref":"#/$defs/NonEmptyString"},"verification":{"$ref":"#/$defs/NonEmptyString"},"body":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"NewPolicyUnit":{"type":"object","required":["id","heading_chain","semantic_revision","intent","aliases","predecessors","successors"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"heading_chain":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/NonEmptyString"}},"semantic_revision":{"const":1},"intent":{"$ref":"#/$defs/NonEmptyString"},"aliases":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"predecessors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"PreservePolicySemantics":{"type":"object","required":["kind","semantic_revision","intent"],"properties":{"kind":{"const":"preserve"},"semantic_revision":{"type":"integer","minimum":1},"intent":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"ChangePolicySemantics":{"type":"object","required":["kind","accepted_semantic_revision","proposed_semantic_revision","intent"],"properties":{"kind":{"const":"change"},"accepted_semantic_revision":{"type":"integer","minimum":1},"proposed_semantic_revision":{"type":"integer","minimum":1},"intent":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PolicySemanticIntent":{"oneOf":[{"$ref":"#/$defs/PreservePolicySemantics"},{"$ref":"#/$defs/ChangePolicySemantics"}]},"CreateStandardEdit":{"type":"object","required":["kind","standard","requires","specializes","policy_units"],"properties":{"kind":{"const":"create-standard"},"standard":{"$ref":"#/$defs/StandardContent"},"requires":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"policy_units":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/NewPolicyUnit"}}},"additionalProperties":false},"RegisterPolicyUnitEdit":{"type":"object","description":"Register an explicitly selected policy scope in an existing standard. The Engine owns declaration placement and validates the final candidate.","required":["kind","standard","policy_unit"],"properties":{"kind":{"const":"register-policy-unit"},"standard":{"$ref":"#/$defs/CanonicalId"},"policy_unit":{"$ref":"#/$defs/NewPolicyUnit"}},"additionalProperties":false},"ReviseStandardEdit":{"type":"object","required":["kind","standard"],"properties":{"kind":{"const":"revise-standard"},"standard":{"$ref":"#/$defs/StandardContent"},"scope_updates":{"type":"array","items":{"$ref":"#/$defs/PolicyScopeUpdate"}}},"additionalProperties":false},"RevisePolicyUnitEdit":{"type":"object","required":["kind","policy","title","body","semantics"],"properties":{"kind":{"const":"revise-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"title":{"$ref":"#/$defs/NonEmptyString"},"body":{"$ref":"#/$defs/NonEmptyString"},"semantics":{"$ref":"#/$defs/PolicySemanticIntent"}},"additionalProperties":false},"MovePolicyUnitEdit":{"type":"object","required":["kind","policy","standard","semantics"],"properties":{"kind":{"const":"move-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"standard":{"$ref":"#/$defs/CanonicalId"},"after_policy":{"$ref":"#/$defs/CanonicalId"},"semantics":{"$ref":"#/$defs/PolicySemanticIntent"}},"additionalProperties":false},"RetirePolicyUnitEdit":{"type":"object","required":["kind","policy","retired_semantic_revision","successors","relationship_dispositions","evidence"],"properties":{"kind":{"const":"retire-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"retired_semantic_revision":{"type":"integer","minimum":1},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"relationship_dispositions":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/RelationshipDisposition"}},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"RetireStandardEdit":{"type":"object","required":["kind","standard","successors","relationship_dispositions","evidence"],"properties":{"kind":{"const":"retire-standard"},"standard":{"$ref":"#/$defs/CanonicalId"},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"relationship_dispositions":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/RelationshipDisposition"}},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"ReplaceStandardRelationshipsEdit":{"type":"object","required":["kind","standard","requires","specializes","rationale"],"properties":{"kind":{"const":"replace-standard-relationships"},"standard":{"$ref":"#/$defs/CanonicalId"},"requires":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"AuthoringTargetHandle":{"type":"object","required":["kind","snapshot","id","schema_version"],"properties":{"kind":{"const":"authoring-target-handle"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"id":{"$ref":"#/$defs/ChildId"},"schema_version":{"const":5}},"additionalProperties":false},"RelationshipConsumer":{"oneOf":[{"$ref":"#/$defs/CanonicalId"},{"$ref":"#/$defs/AuthoringTargetHandle"}]},"PolicyRelationship":{"type":"object","required":["source_policy","consumer","relation","applicability","source_scope","consumer_scope","evidence_owner","rationale"],"properties":{"source_policy":{"$ref":"#/$defs/CanonicalId"},"consumer":{"$ref":"#/$defs/RelationshipConsumer"},"relation":{"enum":["normative-consumer","router-projection","prompt-projection","template-projection","reference-projection","fixture-projection","enforcement-suite-projection","documentation-projection","implementation-projection"]},"applicability":{"$ref":"#/$defs/ApplicabilityExpression"},"source_scope":{"oneOf":[{"$ref":"#/$defs/ReviewScope"},{"type":"null"}]},"consumer_scope":{"oneOf":[{"$ref":"#/$defs/ReviewScope"},{"type":"null"}]},"evidence_owner":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PutPolicyRelationshipEdit":{"type":"object","required":["kind","relationship"],"properties":{"kind":{"const":"put-policy-relationship"},"relationship":{"$ref":"#/$defs/PolicyRelationship"}},"additionalProperties":false},"RemovePolicyRelationshipEdit":{"type":"object","required":["kind","relationship"],"properties":{"kind":{"const":"remove-policy-relationship"},"relationship":{"$ref":"#/$defs/PolicyRelationship"}},"additionalProperties":false},"ModuleRelationshipKey":{"type":"object","required":["kind","relation","source","target"],"properties":{"kind":{"const":"module-relationship"},"relation":{"enum":["requires","specializes"]},"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"PolicyRelationshipKey":{"type":"object","required":["kind","source_policy","consumer","relation"],"properties":{"kind":{"const":"policy-relationship"},"source_policy":{"$ref":"#/$defs/CanonicalId"},"consumer":{"$ref":"#/$defs/RelationshipConsumer"},"relation":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"RelationshipKey":{"oneOf":[{"$ref":"#/$defs/ModuleRelationshipKey"},{"$ref":"#/$defs/PolicyRelationshipKey"}]},"RelationshipDisposition":{"type":"object","required":["relationship","disposition","rationale","evidence"],"properties":{"relationship":{"$ref":"#/$defs/RelationshipKey"},"disposition":{"enum":["remove","retarget"]},"replacement_consumer":{"$ref":"#/$defs/RelationshipConsumer"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"StandardEdit":{"oneOf":[{"$ref":"#/$defs/CreateStandardEdit"},{"$ref":"#/$defs/RegisterPolicyUnitEdit"},{"$ref":"#/$defs/ReviseStandardEdit"},{"$ref":"#/$defs/RevisePolicyUnitEdit"},{"$ref":"#/$defs/MovePolicyUnitEdit"},{"$ref":"#/$defs/RetirePolicyUnitEdit"},{"$ref":"#/$defs/RetireStandardEdit"},{"$ref":"#/$defs/ReplaceStandardRelationshipsEdit"},{"$ref":"#/$defs/PutPolicyRelationshipEdit"},{"$ref":"#/$defs/RemovePolicyRelationshipEdit"},{"$ref":"#/$defs/PutRoutingRuleEdit"},{"$ref":"#/$defs/RemoveRoutingRuleEdit"},{"$ref":"#/$defs/PutRoutingFactEdit"},{"$ref":"#/$defs/RemoveRoutingFactEdit"},{"$ref":"#/$defs/AuditPolicyUnitEdit"},{"$ref":"#/$defs/RewriteNavigationIndexEdit"},{"$ref":"#/$defs/PutDecisionProvenanceEdit"},{"$ref":"#/$defs/RetireDecisionProvenanceEdit"},{"$ref":"#/$defs/ApproveApplicationContentEdit"},{"$ref":"#/$defs/WithdrawApplicationContentEdit"},{"$ref":"#/$defs/ReviseOperationalArtifactEdit"},{"$ref":"#/$defs/RegisterConsumerEdit"}]},"StandardsChangeSet":{"type":"object","required":["purpose","edits"],"properties":{"purpose":{"$ref":"#/$defs/StandardsChangePurpose"},"edits":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/StandardEdit"}}},"additionalProperties":false},"ProposalSummary":{"type":"object","required":["proposal","head_revision"],"properties":{"proposal":{"$ref":"#/$defs/ProposalHandle"},"head_revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"CreateProposalCall":{"type":"object","required":["kind","base_snapshot","change_set"],"properties":{"kind":{"const":"create-proposal"},"base_snapshot":{"$ref":"#/$defs/SnapshotHandle"},"change_set":{"$ref":"#/$defs/StandardsChangeSet"}},"additionalProperties":false},"CreateProposalResult":{"type":"object","required":["kind","proposal","revision"],"properties":{"kind":{"const":"create-proposal-result"},"proposal":{"$ref":"#/$defs/ProposalHandle"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"FindProposalsCall":{"type":"object","required":["kind"],"properties":{"kind":{"const":"find-proposals"},"after":{"$ref":"#/$defs/ProposalHandle"},"limit":{"type":"integer","minimum":1,"default":50}},"additionalProperties":false},"FindProposalsResult":{"type":"object","required":["kind","proposals"],"properties":{"kind":{"const":"find-proposals-result"},"proposals":{"type":"array","items":{"$ref":"#/$defs/ProposalSummary"}},"continuation":{"$ref":"#/$defs/ProposalHandle"}},"additionalProperties":false},"ReviseProposalCall":{"type":"object","required":["kind","expected_revision","change_set"],"properties":{"kind":{"const":"revise-proposal"},"expected_revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"change_set":{"$ref":"#/$defs/StandardsChangeSet"}},"additionalProperties":false},"ReviseProposalResult":{"type":"object","required":["kind","proposal","revision"],"properties":{"kind":{"const":"revise-proposal-result"},"proposal":{"$ref":"#/$defs/ProposalHandle"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"DeleteSnapshotCall":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"delete-snapshot"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"DeleteSnapshotResult":{"type":"object","required":["kind","snapshot","purge_deadline"],"properties":{"kind":{"const":"delete-snapshot-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"purge_deadline":{"$ref":"#/$defs/Timestamp"}},"additionalProperties":false},"UndeleteSnapshotCall":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"undelete-snapshot"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"UndeleteSnapshotResult":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"undelete-snapshot-result"},"snapshot":{"$ref":"#/$defs/ActiveSnapshotSummary"}},"additionalProperties":false},"QueryNextOperation":{"type":"object","required":["operation","request_kind","snapshot"],"properties":{"operation":{"const":"query"},"request_kind":{"enum":["route","read","related"]},"target":{"$ref":"#/$defs/CanonicalId"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"QueryProposalNextOperation":{"type":"object","required":["operation","request_kind","revision"],"properties":{"operation":{"const":"query_proposal"},"request_kind":{"enum":["route","read","related"]},"target":{"$ref":"#/$defs/CanonicalId"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"ResolveNextOperation":{"type":"object","required":["operation","request_kind","analysis"],"properties":{"operation":{"const":"resolve"},"request_kind":{"enum":["provide-fact","consumer-disposition","impact-disposition","coverage-attestation"]},"target":{"$ref":"#/$defs/CanonicalId"},"work":{"$ref":"#/$defs/AnalysisChildHandle"},"analysis":{"$ref":"#/$defs/AnalysisHandle"}},"additionalProperties":false},"InspectNextOperation":{"type":"object","required":["operation","request_kind","handle"],"properties":{"operation":{"const":"inspect"},"request_kind":{"const":"inspect"},"handle":{"$ref":"#/$defs/InspectableHandle"}},"additionalProperties":false},"NextOperation":{"oneOf":[{"$ref":"#/$defs/QueryNextOperation"},{"$ref":"#/$defs/ResolveNextOperation"},{"$ref":"#/$defs/InspectNextOperation"},{"$ref":"#/$defs/FocusedQueryNextOperation"},{"$ref":"#/$defs/WorkflowDetailsNextOperation"}]},"QueryCall":{"type":"object","required":["snapshot","request"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"request":{"$ref":"#/$defs/QueryRequest"}},"additionalProperties":false},"QueryProposalCall":{"type":"object","required":["revision","request"],"properties":{"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"request":{"$ref":"#/$defs/QueryRequest"}},"additionalProperties":false},"AnalyzeProposalCall":{"type":"object","required":["revision"],"properties":{"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"ReviewDecision":{"type":"object","required":["owner","decision","rationale","evidence"],"properties":{"owner":{"enum":["consumer","impact","audit"]},"decision":{"const":"accept"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"ReviewProposalCall":{"type":"object","required":["kind","analysis","decisions"],"properties":{"kind":{"const":"review-proposal"},"analysis":{"$ref":"#/$defs/AnalysisHandle"},"decisions":{"type":"array","minItems":3,"maxItems":3,"uniqueItems":true,"items":{"$ref":"#/$defs/ReviewDecision"}},"prior_readiness":{"$ref":"#/$defs/ReadinessHandle"}},"additionalProperties":false},"ReviewProposalResult":{"type":"object","required":["kind","readiness","revision","status"],"properties":{"kind":{"const":"review-proposal-result"},"readiness":{"$ref":"#/$defs/ReadinessHandle"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"status":{"const":"ready"}},"additionalProperties":false},"ApplyProposalCall":{"type":"object","required":["kind","readiness"],"properties":{"kind":{"const":"apply-proposal"},"readiness":{"$ref":"#/$defs/ReadinessHandle"}},"additionalProperties":false},"ApplyProposalResult":{"type":"object","required":["kind","application","status","publication","checkout"],"properties":{"kind":{"const":"apply-proposal-result"},"application":{"$ref":"#/$defs/ApplicationHandle"},"status":{"const":"applied"},"publication":{"$ref":"#/$defs/ApplicationPublicationReceipt"},"checkout":{"$ref":"#/$defs/PublicationCheckoutObservation"}},"additionalProperties":false},"RecoverApplicationCall":{"type":"object","required":["kind","readiness"],"properties":{"kind":{"const":"recover-application"},"readiness":{"$ref":"#/$defs/ReadinessHandle"},"action":{"enum":["observe","complete-publication"],"description":"Omit or select observe to reconcile only. Explicit complete-publication revalidates and attempts the same admitted candidate against its original expected target; it requires current publication authorization."}},"additionalProperties":false,"description":"Recover an admitted application. Observation performs no Git writes. Explicit completion reconstructs and verifies the exact admitted candidate before one compare-and-swap attempt."},"RecoverApplicationResult":{"type":"object","required":["kind","application","status","publication","checkout"],"properties":{"kind":{"const":"recover-application-result"},"application":{"$ref":"#/$defs/ApplicationHandle"},"status":{"const":"applied"},"publication":{"$ref":"#/$defs/ApplicationPublicationReceipt"},"checkout":{"$ref":"#/$defs/PublicationCheckoutObservation"}},"additionalProperties":false},"ApplicationRecoveryRequiredResult":{"type":"object","required":["kind","application","status","code","outcome","message","publication","checkout"],"properties":{"kind":{"const":"application-recovery-required-result"},"application":{"$ref":"#/$defs/ApplicationHandle"},"status":{"const":"recovery-required"},"code":{"enum":["APPLICATION.PUBLICATION_UNAVAILABLE","APPLICATION.OBSERVATION_UNAVAILABLE","APPLICATION.OUTCOME_OBSERVATION_UNAVAILABLE","APPLICATION.OUTCOME_PERSISTENCE_UNAVAILABLE","APPLICATION.RECOVERY_TARGET_UNCERTAIN","APPLICATION.RECOVERY_TARGET_DIVERGED","APPLICATION.RECOVERY_BLOCKED"]},"outcome":{"const":"unavailable"},"message":{"$ref":"#/$defs/NonEmptyString"},"publication":{"$ref":"#/$defs/ApplicationPublicationReceipt"},"checkout":{"$ref":"#/$defs/PublicationCheckoutObservation"},"details":{"type":"object","additionalProperties":{"$ref":"#/$defs/ScalarValue"}}},"additionalProperties":false},"PublicationTargetObservation":{"description":"Fresh bounded observation of the configured target ref; an unavailable revision is null.","type":"object","required":["kind","status","revision"],"properties":{"kind":{"const":"publication-target-observation"},"status":{"enum":["candidate","expected","diverged","unavailable"]},"revision":{"oneOf":[{"$ref":"#/$defs/GitObjectId"},{"type":"null"}]}},"additionalProperties":false},"ApplicationPublicationReceipt":{"description":"Durable application identity and exact candidate facts, separate from the fresh target observation.","type":"object","required":["kind","application","candidate_commit","candidate_tree","target_ref","expected_predecessor","durable_state","target_observation"],"properties":{"kind":{"const":"application-publication-receipt"},"application":{"$ref":"#/$defs/ApplicationHandle"},"candidate_commit":{"$ref":"#/$defs/GitObjectId"},"candidate_tree":{"oneOf":[{"$ref":"#/$defs/GitObjectId"},{"type":"null"}]},"target_ref":{"const":"refs/heads/main"},"expected_predecessor":{"$ref":"#/$defs/GitObjectId"},"durable_state":{"enum":["applied","admitted","unknown"]},"target_observation":{"$ref":"#/$defs/PublicationTargetObservation"}},"additionalProperties":false},"PublicationPathCounts":{"type":"object","required":["predecessor","candidate","conflicted"],"properties":{"predecessor":{"type":["integer","null"],"minimum":0},"candidate":{"type":["integer","null"],"minimum":0},"conflicted":{"type":["integer","null"],"minimum":0}},"additionalProperties":false},"PublicationCheckoutObservation":{"description":"Fresh read-only observation of one selected checkout. Unavailable observations use null for every fact that could not be established.","type":"object","required":["kind","status","worktree_id","symbolic_branch","head","index_observation","publication_path_count","index_paths","worktree_paths"],"properties":{"kind":{"const":"publication-checkout-observation"},"status":{"enum":["not-observed","unavailable","not-target-checkout","current","needs-reconciliation","conflicted"]},"worktree_id":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"symbolic_branch":{"oneOf":[{"$ref":"#/$defs/NonEmptyString"},{"type":"null"}]},"head":{"oneOf":[{"$ref":"#/$defs/GitObjectId"},{"type":"null"}]},"index_observation":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"publication_path_count":{"type":["integer","null"],"minimum":0},"index_paths":{"$ref":"#/$defs/PublicationPathCounts"},"worktree_paths":{"$ref":"#/$defs/PublicationPathCounts"}},"additionalProperties":false},"PolicySummary":{"type":"object","required":["handle","authority","scope"],"properties":{"handle":{"$ref":"#/$defs/SnapshotChildHandle"},"authority":{"enum":["normative","projection","contextual","evidence"]},"scope":{"$ref":"#/$defs/ReviewScope"}},"additionalProperties":false},"RelationshipSummary":{"type":"object","required":["handle","source","target","relation","groups","direction","traversal_eligible","applicability"],"properties":{"handle":{"$ref":"#/$defs/SnapshotChildHandle"},"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"relation":{"$ref":"#/$defs/CanonicalId"},"groups":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"minItems":1,"uniqueItems":true},"direction":{"enum":["incoming","outgoing"]},"traversal_eligible":{"type":"boolean"},"applicability":{"enum":["true","false","unknown","not-declared"]}},"additionalProperties":false},"ProposalPolicySummary":{"type":"object","required":["id","authority","scope"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"authority":{"enum":["normative","projection","contextual","evidence"]},"scope":{"$ref":"#/$defs/ReviewScope"}},"additionalProperties":false},"ProposalRelationshipSummary":{"type":"object","required":["source","target","relation","groups","direction","traversal_eligible","applicability"],"properties":{"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"relation":{"$ref":"#/$defs/CanonicalId"},"groups":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"minItems":1,"uniqueItems":true},"direction":{"enum":["incoming","outgoing"]},"traversal_eligible":{"type":"boolean"},"applicability":{"enum":["true","false","unknown","not-declared"]}},"additionalProperties":false},"RouteResult":{"type":"object","required":["kind","snapshot","reading_plan","unresolved_questions","next_operations"],"properties":{"kind":{"const":"route-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/Question"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"ReadResult":{"type":"object","required":["kind","snapshot","policy","content","requires","specializes","related","next_operations"],"properties":{"kind":{"const":"read-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"policy":{"$ref":"#/$defs/PolicySummary"},"content":{"type":"string"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"related":{"type":"array","items":{"$ref":"#/$defs/RelationshipSummary"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"},"routing":{"$ref":"#/$defs/RoutingConfiguration"},"coverage":{"$ref":"#/$defs/ReadCoverage"},"application_exposure":{"$ref":"#/$defs/ApplicationExposureState"},"provenance":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"PolicyUnitMapping":{"type":"object","required":["state","policy_units"],"properties":{"state":{"enum":["exact-policy-unit","policy-units-present","incomplete"]},"reason":{"const":"no-policy-units"},"policy_units":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true}},"additionalProperties":false},"RelatedResult":{"type":"object","required":["kind","snapshot","target","policy_unit_mapping","relationships","next_operations"],"properties":{"kind":{"const":"related-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"target":{"$ref":"#/$defs/CanonicalId"},"authoring_target":{"$ref":"#/$defs/AuthoringTargetHandle"},"policy_unit_mapping":{"$ref":"#/$defs/PolicyUnitMapping"},"relationships":{"type":"array","items":{"$ref":"#/$defs/RelationshipSummary"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"QueryResult":{"oneOf":[{"$ref":"#/$defs/RouteResult"},{"$ref":"#/$defs/ReadResult"},{"$ref":"#/$defs/RelatedResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/OperationalReadResult"}]},"ProposalRouteResult":{"type":"object","required":["kind","revision","reading_plan","unresolved_questions","next_operations"],"properties":{"kind":{"const":"proposal-route-result"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/Question"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/QueryProposalNextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"ProposalReadResult":{"type":"object","required":["kind","revision","policy","content","requires","specializes","related","next_operations"],"properties":{"kind":{"const":"proposal-read-result"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"policy":{"$ref":"#/$defs/ProposalPolicySummary"},"content":{"type":"string"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"related":{"type":"array","items":{"$ref":"#/$defs/ProposalRelationshipSummary"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/QueryProposalNextOperation"}},"summary":{"type":"string"},"routing":{"$ref":"#/$defs/RoutingConfiguration"},"coverage":{"$ref":"#/$defs/ReadCoverage"},"application_exposure":{"$ref":"#/$defs/ApplicationExposureState"},"provenance":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"ProposalRelatedResult":{"type":"object","required":["kind","revision","target","policy_unit_mapping","relationships","next_operations"],"properties":{"kind":{"const":"proposal-related-result"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"target":{"$ref":"#/$defs/CanonicalId"},"authoring_target":{"$ref":"#/$defs/AuthoringTargetHandle"},"policy_unit_mapping":{"$ref":"#/$defs/PolicyUnitMapping"},"relationships":{"type":"array","items":{"$ref":"#/$defs/ProposalRelationshipSummary"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/QueryProposalNextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"QueryProposalResult":{"oneOf":[{"$ref":"#/$defs/ProposalRouteResult"},{"$ref":"#/$defs/ProposalReadResult"},{"$ref":"#/$defs/ProposalRelatedResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/OperationalReadResult"}]},"AnalysisRequest":{"type":"object","required":["kind","base_snapshot","proposed_snapshot","changes","semantic_proposals","contract_version"],"properties":{"kind":{"const":"analysis-request"},"base_snapshot":{"$ref":"#/$defs/SnapshotHandle"},"proposed_snapshot":{"$ref":"#/$defs/SnapshotHandle"},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"},"minItems":1},"semantic_proposals":{"type":"array","items":{"$ref":"#/$defs/SemanticProposal"},"uniqueItems":true},"prior_analysis":{"$ref":"#/$defs/AnalysisHandle"},"contract_version":{"const":6}},"additionalProperties":false},"PrepareCall":{"type":"object","required":["request"],"properties":{"request":{"$ref":"#/$defs/AnalysisRequest"}},"additionalProperties":false},"AnalysisContext":{"type":"object","required":["kind","handle","subjects","changes","semantic_proposals"],"properties":{"kind":{"const":"analysis-context"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"subjects":{"type":"array","items":{"$ref":"#/$defs/ChangedPolicyUnit"},"uniqueItems":true},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"},"minItems":1,"uniqueItems":true},"semantic_proposals":{"type":"array","items":{"$ref":"#/$defs/SemanticProposal"},"uniqueItems":true}},"additionalProperties":false},"AuthorizationReference":{"type":"object","required":["id","issuer","capability","authority_digest"],"properties":{"id":{"$ref":"#/$defs/AuthorizationId"},"issuer":{"$ref":"#/$defs/CanonicalId"},"capability":{"$ref":"#/$defs/CanonicalId"},"authority_digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"ProviderReference":{"type":"object","required":["id","contract","contract_version","input_digest"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"contract":{"$ref":"#/$defs/CanonicalId"},"contract_version":{"$ref":"#/$defs/NonEmptyString"},"input_digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"AuthorizationRecord":{"type":"object","required":["reference","issuer_semantic_revision","principal","action","subject_kind","subject_id","authorization_evidence","revocation_authority","revocation_authority_semantic_revision","revocation_evidence"],"properties":{"reference":{"$ref":"#/$defs/AuthorizationReference"},"issuer_semantic_revision":{"type":"integer","minimum":1},"principal":{"$ref":"#/$defs/CanonicalId"},"action":{"$ref":"#/$defs/CanonicalId"},"subject_kind":{"$ref":"#/$defs/CanonicalId"},"subject_id":{"$ref":"#/$defs/NonEmptyString"},"authorization_evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true},"revocation_authority":{"$ref":"#/$defs/CanonicalId"},"revocation_authority_semantic_revision":{"type":"integer","minimum":1},"revocation_evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true}},"additionalProperties":false},"DomainContractReference":{"type":"object","required":["id","version"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"version":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"AnalysisExecutionContractView":{"type":"object","required":["authorization_authority_digest","providers"],"properties":{"authorization_authority_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"providers":{"type":"array","items":{"$ref":"#/$defs/ProviderReference"},"uniqueItems":true}},"additionalProperties":false},"FactRequirement":{"type":"object","required":["kind","handle","fact","fact_semantic_revision","fact_contract_digest","context","value_contract","answer_contract","evidence_contract","authorization_capability"],"properties":{"kind":{"const":"fact-requirement"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"fact":{"$ref":"#/$defs/CanonicalId"},"fact_semantic_revision":{"type":"integer","minimum":1},"fact_contract_digest":{"$ref":"#/$defs/Digest"},"context":{"$ref":"#/$defs/AnalysisChildHandle"},"value_contract":{"$ref":"#/$defs/FactValueContract"},"answer_contract":{"$ref":"#/$defs/CanonicalId"},"evidence_contract":{"$ref":"#/$defs/CanonicalId"},"authorization_capability":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"FactRequirementWork":{"type":"object","required":["requirement","prompt","dependent_programs"],"properties":{"requirement":{"$ref":"#/$defs/FactRequirement"},"prompt":{"$ref":"#/$defs/NonEmptyString"},"dependent_programs":{"type":"array","items":{"$ref":"#/$defs/NonEmptyString"},"minItems":1,"uniqueItems":true}},"additionalProperties":false},"FactObservation":{"type":"object","required":["kind","handle","requirement","value","evidence","authorization"],"properties":{"kind":{"const":"fact-observation"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"value":{"$ref":"#/$defs/FactValue"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true},"authorization":{"$ref":"#/$defs/AuthorizationReference"},"provider":{"$ref":"#/$defs/ProviderReference"}},"additionalProperties":false},"Obligation":{"type":"object","required":["handle","kind","target","scope","reasons","state","permitted_submissions","fingerprint"],"properties":{"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"kind":{"enum":["consumer-review","impact-review","lifecycle-impact-review","audit-coverage","unmapped-normative-change"]},"target":{"$ref":"#/$defs/CanonicalId"},"scope":{"$ref":"#/$defs/ReviewScope"},"reasons":{"type":"array","items":{"$ref":"#/$defs/SelectionReason"},"minItems":1,"uniqueItems":true},"state":{"enum":["required","resolved","blocked"]},"applicability":{"enum":["true","false","unknown","not-declared"]},"permitted_submissions":{"type":"array","items":{"enum":["consumer-disposition","impact-disposition","coverage-attestation"]},"minItems":1,"uniqueItems":true},"review_contract":{"$ref":"#/$defs/ConsumerReviewContract"},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"ProvideFactSubmission":{"type":"object","required":["kind","requirement","value","evidence"],"properties":{"kind":{"const":"provide-fact"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"value":{"$ref":"#/$defs/FactValue"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true}},"additionalProperties":false},"ConsumerDispositionSubmission":{"type":"object","required":["kind","obligation","result","rationale","evidence","fingerprint"],"properties":{"kind":{"const":"consumer-disposition"},"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"result":{"enum":["updated","reviewed-no-change","not-applicable","blocked"]},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"ImpactDispositionSubmission":{"type":"object","required":["kind","obligation","result","rationale","evidence","fingerprint"],"properties":{"kind":{"const":"impact-disposition"},"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"result":{"enum":["confirmed","resolved-no-impact","requires-change","blocked"]},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"CoverageAttestationClaim":{"type":"object","required":["requirement","conclusion","evidence","explicit_exclusions","rationale","auditor_provenance"],"properties":{"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"conclusion":{"const":"complete"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true},"explicit_exclusions":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"uniqueItems":true},"rationale":{"$ref":"#/$defs/NonEmptyString"},"auditor_provenance":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"CoverageAttestationSubmission":{"type":"object","required":["kind","claim"],"properties":{"kind":{"const":"coverage-attestation"},"claim":{"$ref":"#/$defs/CoverageAttestationClaim"}},"additionalProperties":false},"Submission":{"oneOf":[{"$ref":"#/$defs/ProvideFactSubmission"},{"$ref":"#/$defs/ConsumerDispositionSubmission"},{"$ref":"#/$defs/ImpactDispositionSubmission"},{"$ref":"#/$defs/CoverageAttestationSubmission"}]},"ResolveCall":{"type":"object","required":["analysis","submission"],"properties":{"analysis":{"$ref":"#/$defs/AnalysisHandle"},"submission":{"$ref":"#/$defs/Submission"}},"additionalProperties":false},"CoverageRequirement":{"type":"object","required":["kind","handle","subject","owner","semantic_revision","relationship_kinds","horizon","required_evidence_contract"],"properties":{"kind":{"const":"coverage-requirement"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"subject":{"$ref":"#/$defs/CanonicalId"},"owner":{"$ref":"#/$defs/CanonicalId"},"semantic_revision":{"type":"integer","minimum":1},"relationship_kinds":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"horizon":{"$ref":"#/$defs/CanonicalId"},"required_evidence_contract":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"CoverageAttestation":{"type":"object","required":["kind","requirement","conclusion","evidence","explicit_exclusions","rationale","auditor_provenance","schema_version","authorization"],"properties":{"kind":{"const":"coverage-attestation"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"conclusion":{"const":"complete"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1},"explicit_exclusions":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"}},"rationale":{"$ref":"#/$defs/NonEmptyString"},"auditor_provenance":{"$ref":"#/$defs/NonEmptyString"},"schema_version":{"const":4},"authorization":{"$ref":"#/$defs/AuthorizationReference"}},"additionalProperties":false},"CoverageCertificate":{"type":"object","required":["kind","handle","requirement","subject","owner","semantic_revision","horizon_digest","relationship_digest","evidence_digests","fact_schema_digest"],"properties":{"kind":{"const":"coverage-certificate"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"subject":{"$ref":"#/$defs/CanonicalId"},"owner":{"$ref":"#/$defs/CanonicalId"},"semantic_revision":{"type":"integer","minimum":1},"horizon_digest":{"$ref":"#/$defs/Digest"},"relationship_digest":{"$ref":"#/$defs/Digest"},"evidence_digests":{"type":"array","items":{"$ref":"#/$defs/Digest"},"uniqueItems":true},"fact_schema_digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"DispositionRecord":{"type":"object","required":["obligation","kind","result","rationale","evidence","authorization","fingerprint"],"properties":{"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"kind":{"enum":["consumer-disposition","impact-disposition"]},"result":{"$ref":"#/$defs/NonEmptyString"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"}},"authorization":{"$ref":"#/$defs/AuthorizationReference"},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"AnalysisState":{"type":"object","required":["kind","handle","base_snapshot","proposed_reference","changes","semantic_proposals","fact_observations","dispositions","coverage_attestations","authorization_records","domain_contracts","execution_contracts","contract_version"],"properties":{"kind":{"const":"analysis-state"},"handle":{"$ref":"#/$defs/AnalysisHandle"},"base_snapshot":{"$ref":"#/$defs/SnapshotHandle"},"proposed_reference":{"$ref":"#/$defs/AnalysisMaterialHandle"},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"},"minItems":1,"uniqueItems":true},"semantic_proposals":{"type":"array","items":{"$ref":"#/$defs/SemanticProposal"},"uniqueItems":true},"fact_observations":{"type":"array","items":{"$ref":"#/$defs/FactObservation"},"uniqueItems":true},"dispositions":{"type":"array","items":{"$ref":"#/$defs/DispositionRecord"},"uniqueItems":true},"coverage_attestations":{"type":"array","items":{"$ref":"#/$defs/CoverageAttestation"},"uniqueItems":true},"authorization_records":{"type":"array","items":{"$ref":"#/$defs/AuthorizationRecord"},"uniqueItems":true},"domain_contracts":{"type":"array","items":{"$ref":"#/$defs/DomainContractReference"},"minItems":1,"uniqueItems":true},"execution_contracts":{"$ref":"#/$defs/AnalysisExecutionContractView"},"contract_version":{"const":7}},"additionalProperties":false},"PendingResult":{"type":"object","required":["kind","handle","status","context","changes","changed_units","obligations","fact_requirements","reading_plan","next_operations"],"properties":{"kind":{"const":"pending-result"},"handle":{"$ref":"#/$defs/AnalysisHandle"},"status":{"const":"needs-action"},"context":{"$ref":"#/$defs/AnalysisContext"},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"}},"changed_units":{"type":"array","items":{"$ref":"#/$defs/ChangedPolicyUnit"}},"obligations":{"type":"array","items":{"$ref":"#/$defs/Obligation"}},"fact_requirements":{"type":"array","items":{"$ref":"#/$defs/FactRequirementWork"}},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"CompleteResult":{"type":"object","required":["kind","handle","status","context","changes","changed_units","coverage_certificates","fact_observations","dispositions","reading_plan","completion"],"properties":{"kind":{"const":"complete-result"},"handle":{"$ref":"#/$defs/AnalysisHandle"},"status":{"const":"complete"},"context":{"$ref":"#/$defs/AnalysisContext"},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"}},"changed_units":{"type":"array","items":{"$ref":"#/$defs/ChangedPolicyUnit"}},"coverage_certificates":{"type":"array","items":{"$ref":"#/$defs/CoverageCertificate"},"uniqueItems":true},"fact_observations":{"type":"array","items":{"$ref":"#/$defs/FactObservation"},"uniqueItems":true},"dispositions":{"type":"array","items":{"$ref":"#/$defs/DispositionRecord"}},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"completion":{"$ref":"#/$defs/CompletionProof"},"summary":{"type":"string"}},"additionalProperties":false},"RepositoryPath":{"type":"array","items":{"$ref":"#/$defs/NonEmptyString"},"minItems":1},"ProvenanceRecord":{"type":"object","required":["snapshot","path"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"path":{"$ref":"#/$defs/RepositoryPath"}},"additionalProperties":false},"SnapshotInspectionResult":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"snapshot-inspection-result"},"snapshot":{"$ref":"#/$defs/SnapshotSummary"}},"additionalProperties":false},"PolicyInspectionResult":{"type":"object","required":["kind","policy","declaration","representation_digest","structural_digest","provenance"],"properties":{"kind":{"const":"policy-inspection-result"},"policy":{"$ref":"#/$defs/SnapshotChildHandle"},"declaration":{"oneOf":[{"$ref":"#/$defs/CanonicalModuleDeclaration"},{"$ref":"#/$defs/PolicyUnitDeclaration"}]},"representation_digest":{"$ref":"#/$defs/Digest"},"structural_digest":{"$ref":"#/$defs/Digest"},"provenance":{"$ref":"#/$defs/ProvenanceRecord"}},"additionalProperties":false},"RelationshipInspectionResult":{"type":"object","required":["kind","relationship","policy_semantics","provenance"],"properties":{"kind":{"const":"relationship-inspection-result"},"relationship":{"$ref":"#/$defs/RelationshipSummary"},"policy_semantics":{"oneOf":[{"$ref":"#/$defs/PolicyRelationshipInspection"},{"type":"null"}]},"provenance":{"$ref":"#/$defs/ProvenanceRecord"}},"additionalProperties":false},"AnalysisInspectionResult":{"type":"object","required":["kind","state"],"properties":{"kind":{"const":"analysis-inspection-result"},"state":{"$ref":"#/$defs/AnalysisState"}},"additionalProperties":false},"AnalysisChildArtifact":{"oneOf":[{"$ref":"#/$defs/AnalysisContext"},{"$ref":"#/$defs/FactRequirement"},{"$ref":"#/$defs/FactObservation"},{"$ref":"#/$defs/Obligation"},{"$ref":"#/$defs/CoverageRequirement"},{"$ref":"#/$defs/CoverageCertificate"}]},"AnalysisChildInspectionResult":{"type":"object","required":["kind","handle","artifact"],"properties":{"kind":{"const":"analysis-child-inspection-result"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"artifact":{"$ref":"#/$defs/AnalysisChildArtifact"}},"additionalProperties":false},"InspectionResult":{"oneOf":[{"$ref":"#/$defs/SnapshotInspectionResult"},{"$ref":"#/$defs/PolicyInspectionResult"},{"$ref":"#/$defs/RelationshipInspectionResult"},{"$ref":"#/$defs/AnalysisInspectionResult"},{"$ref":"#/$defs/AnalysisChildInspectionResult"}]},"InspectCall":{"type":"object","required":["handle"],"properties":{"handle":{"$ref":"#/$defs/InspectableHandle"}},"additionalProperties":false},"RejectedResult":{"type":"object","required":["kind","code","outcome","message","details","next_operations"],"properties":{"kind":{"const":"rejected-result"},"code":{"$ref":"#/$defs/CanonicalId"},"outcome":{"enum":["invalid","unavailable","unsupported","unauthorized"]},"target":{"$ref":"#/$defs/NonEmptyString"},"message":{"$ref":"#/$defs/NonEmptyString"},"details":{"type":"object","additionalProperties":{"$ref":"#/$defs/ScalarValue"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"input_feedback":{"$ref":"#/$defs/InputFeedback"},"relationship_groups":{"$ref":"#/$defs/RelationshipGroupsResult"}},"additionalProperties":false},"AuthoredRoutingRule":{"type":"object","required":["id","target","when","condition"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"when":{"$ref":"#/$defs/ApplicabilityExpression"},"condition":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"AuthoredRoutingFact":{"type":"object","required":["id","semantic_revision","type","nullable","values","aliases","meaning","prompt"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"semantic_revision":{"type":"integer","minimum":1},"type":{"enum":["boolean","enum","string","string-set","enum-set","canonical-id"]},"nullable":{"type":"boolean"},"values":{"type":"array","items":{"type":"string"},"uniqueItems":true},"aliases":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"meaning":{"$ref":"#/$defs/NonEmptyString"},"prompt":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PutRoutingRuleEdit":{"type":"object","required":["kind","rule","rationale"],"properties":{"kind":{"const":"put-routing-rule"},"rule":{"$ref":"#/$defs/AuthoredRoutingRule"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"RemoveRoutingRuleEdit":{"type":"object","required":["kind","rule","rationale"],"properties":{"kind":{"const":"remove-routing-rule"},"rule":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PutRoutingFactEdit":{"type":"object","required":["kind","fact","rationale"],"properties":{"kind":{"const":"put-routing-fact"},"fact":{"$ref":"#/$defs/AuthoredRoutingFact"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"RemoveRoutingFactEdit":{"type":"object","required":["kind","fact","rationale"],"properties":{"kind":{"const":"remove-routing-fact"},"fact":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"VerificationFailure":{"type":"object","additionalProperties":false,"required":["code","message","suite","check"],"properties":{"code":{"$ref":"#/$defs/NonEmptyString"},"message":{"$ref":"#/$defs/NonEmptyString"},"suite":{"type":["string","null"]},"check":{"type":["string","null"]}}},"VerificationReport":{"type":"object","additionalProperties":false,"required":["passed","exit_code","suites","checks","failures"],"properties":{"passed":{"type":"boolean"},"exit_code":{"enum":[0,1,2,3,4]},"suites":{"type":"integer","minimum":0},"checks":{"type":"integer","minimum":0},"failures":{"type":"array","items":{"$ref":"#/$defs/VerificationFailure"}}}},"VerifyRepositoryCall":{"type":"object","additionalProperties":false,"required":["kind","refresh_verification_inputs"],"properties":{"kind":{"const":"verify-repository"},"refresh_verification_inputs":{"type":"boolean"}}},"VerifyRepositoryResult":{"type":"object","additionalProperties":false,"required":["kind","refreshed_verification_inputs","verification"],"properties":{"kind":{"const":"verify-repository-result"},"refreshed_verification_inputs":{"type":"boolean"},"verification":{"$ref":"#/$defs/VerificationReport"}}},"VerifyProposalCall":{"type":"object","additionalProperties":false,"required":["kind","revision"],"properties":{"kind":{"const":"verify-proposal"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"readiness":{"$ref":"#/$defs/ReadinessHandle"}}},"VerifyProposalResult":{"type":"object","additionalProperties":false,"required":["kind","revision","verification"],"properties":{"kind":{"const":"verify-proposal-result"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"verification":{"$ref":"#/$defs/VerificationReport"},"readiness":{"$ref":"#/$defs/ReadinessHandle"}}},"RoutingConfiguration":{"type":"object","additionalProperties":false,"required":["facts","rules"],"properties":{"facts":{"type":"array","items":{"$ref":"#/$defs/AuthoredRoutingFact"}},"rules":{"type":"array","items":{"$ref":"#/$defs/AuthoredRoutingRule"}}}},"PolicyCoverageStatus":{"type":"object","required":["subject","requirement_id","status"],"properties":{"subject":{"$ref":"#/$defs/CanonicalId"},"requirement_id":{"$ref":"#/$defs/Digest"},"status":{"enum":["current-attestation","review-required"]},"authority":{"$ref":"#/$defs/CoverageAuditAuthority"}},"additionalProperties":false},"ReadCoverage":{"type":"object","description":"Repository attestation status bound to this snapshot or proposal. Empty subjects means no registered policy units in scope, not complete coverage. Analysis-local attestations are not repository certificates.","required":["subjects"],"properties":{"subjects":{"type":"array","items":{"$ref":"#/$defs/PolicyCoverageStatus"}}},"additionalProperties":false},"AuditPolicyUnitEdit":{"type":"object","required":["kind","policy","rationale"],"properties":{"kind":{"const":"audit-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"CoverageAuditAuthority":{"type":"object","required":["issuer","principal","authorization_id"],"properties":{"issuer":{"$ref":"#/$defs/NonEmptyString"},"principal":{"$ref":"#/$defs/NonEmptyString"},"authorization_id":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"EvidenceCheckRetirement":{"type":"object","additionalProperties":false,"required":["suite","check"],"properties":{"suite":{"type":"string","minLength":1},"check":{"type":"string","minLength":1}}},"EvidenceSuiteDescription":{"type":"object","additionalProperties":false,"required":["suite","description"],"properties":{"suite":{"type":"string","minLength":1},"description":{"type":"string","minLength":1}}},"EvidenceRelationshipUpdate":{"type":"object","additionalProperties":false,"required":["source_policy","consumer","relation","evidence_owner","rationale"],"properties":{"source_policy":{"type":"string","minLength":1},"consumer":{"type":"string","minLength":1},"relation":{"type":"string","minLength":1},"evidence_owner":{"type":"string","minLength":1},"rationale":{"type":"string","minLength":1}}},"EvidenceConsumerRegistration":{"type":"object","additionalProperties":false,"required":["path","artifact_kind","source_policies","relation","evidence_owner","rationale"],"properties":{"path":{"type":"string","minLength":1},"artifact_kind":{"type":"string","enum":["implementation-artifact","fixture"]},"source_policies":{"type":"array","items":{"type":"string","minLength":1},"minItems":1,"uniqueItems":true},"relation":{"type":"string","enum":["implementation-projection","fixture-projection"]},"evidence_owner":{"type":"string","minLength":1},"rationale":{"type":"string","minLength":1}}},"EngineCertificateRetirement":{"type":"object","additionalProperties":false,"required":["subject","requirement_id","rationale"],"properties":{"subject":{"$ref":"#/$defs/CanonicalId"},"requirement_id":{"$ref":"#/$defs/Digest"},"rationale":{"$ref":"#/$defs/NonEmptyString"}}},"EvidenceMaintenancePlan":{"type":"object","additionalProperties":false,"required":["prune_stale_certificates","retire_suites","retire_checks","retire_inputs","suite_descriptions","replacement_evidence_owner","replacement_evidence_rationale","relationship_updates","consumer_registrations"],"properties":{"retire_engine_certificates":{"type":"array","items":{"$ref":"#/$defs/EngineCertificateRetirement"},"uniqueItems":true,"description":"Explicitly retire exact registered Engine-issued certificates by subject and requirement; preserve normative policy and consumer registrations."},"prune_stale_certificates":{"type":"boolean"},"retire_suites":{"type":"array","items":{"type":"string","minLength":1},"uniqueItems":true},"retire_checks":{"type":"array","items":{"$ref":"#/$defs/EvidenceCheckRetirement"}},"retire_inputs":{"type":"array","items":{"type":"string","minLength":1},"uniqueItems":true},"suite_descriptions":{"type":"array","items":{"$ref":"#/$defs/EvidenceSuiteDescription"}},"replacement_evidence_owner":{"type":"string","minLength":1},"replacement_evidence_rationale":{"type":"string","minLength":1},"relationship_updates":{"type":"array","items":{"$ref":"#/$defs/EvidenceRelationshipUpdate"}},"consumer_registrations":{"type":"array","items":{"$ref":"#/$defs/EvidenceConsumerRegistration"}},"unregister_policy_subjects":{"type":"array","items":{"type":"string","minLength":1},"uniqueItems":true,"description":"Remove selected review-subject registrations and their source relationships while preserving normative Markdown."}}},"MaintainEvidenceCall":{"type":"object","additionalProperties":false,"required":["kind","expected_revision","evidence","plan","apply"],"properties":{"kind":{"const":"maintain-evidence"},"expected_revision":{"type":"string","minLength":1},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1},"plan":{"$ref":"#/$defs/EvidenceMaintenancePlan"},"apply":{"type":"boolean"}}},"MaintainEvidenceResult":{"type":"object","additionalProperties":false,"required":["kind","applied","changed_files","removed_files","verification"],"properties":{"kind":{"const":"maintain-evidence-result"},"applied":{"type":"boolean"},"changed_files":{"type":"array","items":{"type":"string","minLength":1}},"removed_files":{"type":"array","items":{"type":"string","minLength":1}},"verification":{"$ref":"#/$defs/VerificationReport"}}},"RouteCall":{"type":"object","required":["facts"],"properties":{"facts":{"$ref":"#/$defs/RoutingFactAssertions"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"content":{"$ref":"#/$defs/RouteContentSelection"},"detail":{"enum":["compact","full"],"description":"Compact authoring selection is default. Full returns the rule explanation. Application always retains its qualified projection."}},"additionalProperties":false},"ReadCall":{"type":"object","required":["target"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"include_routing":{"type":"boolean"},"include_coverage":{"type":"boolean","description":"Include current repository attestation status for registered policy units in this read scope."},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"detail":{"enum":["compact","full"],"description":"Compact preserves exact policy and essential authority; full includes all relationship rows."}},"additionalProperties":false},"RelatedCall":{"type":"object","required":["target","groups","direction","transitive"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"groups":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"direction":{"enum":["incoming","outgoing","both"]},"transitive":{"type":"boolean","default":false},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"CompactReadResult":{"type":"object","required":["kind","snapshot","policy","content","requires","specializes","next_operations","detail"],"properties":{"kind":{"const":"compact-read-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"policy":{"$ref":"#/$defs/PolicySummary"},"content":{"type":"string"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"},"routing":{"$ref":"#/$defs/RoutingConfiguration"},"coverage":{"$ref":"#/$defs/ReadCoverage"},"detail":{"const":"compact"},"application_exposure":{"$ref":"#/$defs/ApplicationExposureState"},"provenance":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"RoutingFactsCall":{"type":"object","additionalProperties":false,"required":[],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"}}},"RoutingFactsResult":{"type":"object","additionalProperties":false,"required":["kind","snapshot","facts"],"properties":{"kind":{"const":"routing-facts-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"facts":{"type":"array","items":{"$ref":"#/$defs/AuthoredRoutingFact"}}}},"RoutingQuestion":{"type":"object","additionalProperties":false,"required":["id","kind","prompt","state","fact"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"kind":{"const":"applicability-fact"},"prompt":{"$ref":"#/$defs/NonEmptyString"},"state":{"const":"required"},"fact":{"$ref":"#/$defs/AuthoredRoutingFact"}}},"RoutingRuleExplanation":{"type":"object","additionalProperties":false,"required":["id","target","when","state"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"when":{"$ref":"#/$defs/ApplicabilityExpression"},"state":{"enum":["selected","unresolved"]}}},"AgentRouteResult":{"type":"object","required":["kind","snapshot","reading_plan","unresolved_questions","next_operations","facts","rules"],"properties":{"kind":{"const":"agent-route-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/RoutingQuestion"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"},"facts":{"$ref":"#/$defs/RoutingFactAssertions"},"rules":{"type":"array","items":{"$ref":"#/$defs/RoutingRuleExplanation"}},"content":{"$ref":"#/$defs/RoutedContentPage"}},"additionalProperties":false},"WorkflowContext":{"oneOf":[{"$ref":"#/$defs/ProposalRevisionHandle"},{"$ref":"#/$defs/AnalysisHandle"},{"$ref":"#/$defs/ReadinessHandle"}]},"ProposeCall":{"type":"object","additionalProperties":false,"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"change_set":{"$ref":"#/$defs/StandardsChangeSet"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["change_set"]},"ReviseCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"change_set":{"$ref":"#/$defs/StandardsChangeSet"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context","change_set"]},"AnalyzeCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"]},"ResolveWorkflowCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"submission":{"$ref":"#/$defs/Submission"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context","submission"]},"ReviewCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"decisions":{"type":"array","minItems":3,"maxItems":3,"uniqueItems":true,"items":{"$ref":"#/$defs/ReviewDecision"}},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context","decisions"]},"ApplyCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"]},"RecoverCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"action":{"enum":["observe","complete-publication"],"description":"Omit or select observe to reconcile only. Explicit complete-publication revalidates and attempts the same admitted candidate against its original expected target; it requires current publication authorization."},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"],"description":"Recover an admitted application. Observation performs no Git writes. Explicit completion reconstructs and verifies the exact admitted candidate before one compare-and-swap attempt."},"WorkflowStatusCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"]},"ResumeCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"]},"WorkflowContinuation":{"type":"object","additionalProperties":false,"properties":{"operation":{"enum":["revise","analyze","resolve_workflow","review","apply","recover","workflow_status","resume","resolve_many"]},"required_inputs":{"type":"array","uniqueItems":true,"items":{"enum":["change_set","submission","decisions","action","submissions"]}}},"required":["operation","required_inputs"],"description":"Select the named operation with the enclosing WorkflowResult context and explicit required inputs. This descriptor is not an authorization grant."},"WorkflowOutcome":{"oneOf":[{"$ref":"#/$defs/CreateProposalResult"},{"$ref":"#/$defs/ReviseProposalResult"},{"$ref":"#/$defs/PendingResult"},{"$ref":"#/$defs/CompleteResult"},{"$ref":"#/$defs/ReviewProposalResult"},{"$ref":"#/$defs/ApplyProposalResult"},{"$ref":"#/$defs/ApplicationRecoveryRequiredResult"},{"$ref":"#/$defs/RecoverApplicationResult"},{"$ref":"#/$defs/RejectedResult"},{"$ref":"#/$defs/WorkflowAnalysisSummary"}]},"WorkflowResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"workflow-result"},"context":{"$ref":"#/$defs/WorkflowContext"},"proposal":{"$ref":"#/$defs/ProposalHandle"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"publication":{"$ref":"#/$defs/ApplicationPublicationReceipt"},"checkout":{"$ref":"#/$defs/PublicationCheckoutObservation"},"status":{"enum":["draft","needs-action","complete","requires-change","ready","recovery-required","applied","rejected","stale"]},"next_operations":{"type":"array","items":{"$ref":"#/$defs/WorkflowContinuation"}},"outcome":{"$ref":"#/$defs/WorkflowOutcome"},"work":{"oneOf":[{"$ref":"#/$defs/WorkflowWorkPage"},{"$ref":"#/$defs/WorkflowWorkDeferred"}]}},"required":["kind","context","proposal","revision","status","next_operations"],"description":"Exact immutable workflow context and relative action descriptors. Successful compact pending propose, revise, analyze and decision submissions include work from the already-produced Analysis. Status observations, full results, stale contexts and other outcomes omit work."},"FocusedQueryNextOperation":{"type":"object","required":["operation","request_kind","snapshot"],"properties":{"operation":{"enum":["route","read","related"]},"request_kind":{"enum":["route","read","related"]},"target":{"$ref":"#/$defs/CanonicalId"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"RewriteNavigationIndexEdit":{"type":"object","required":["kind","entrypoint","destinations","rationale"],"properties":{"kind":{"const":"rewrite-navigation-index"},"entrypoint":{"$ref":"#/$defs/AuthoringTargetHandle"},"destinations":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"minItems":1,"uniqueItems":true},"rationale":{"$ref":"#/$defs/NonEmptyString"},"retargets":{"type":"array","items":{"$ref":"#/$defs/NavigationRetarget"},"uniqueItems":true}},"additionalProperties":false},"NavigationIndexEntry":{"type":"object","required":["id","entrypoint","destinations"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"entrypoint":{"$ref":"#/$defs/AuthoringTargetHandle"},"destinations":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"content":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"NavigationIndexesResult":{"type":"object","required":["kind","authority","indexes","next_operations"],"properties":{"kind":{"const":"navigation-indexes-result"},"authority":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/ProposalRevisionHandle"}]},"indexes":{"type":"array","items":{"$ref":"#/$defs/NavigationIndexEntry"},"minItems":1},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"},"maxItems":0}},"additionalProperties":false},"NavigationRetarget":{"type":"object","required":["entrypoint","standard"],"properties":{"entrypoint":{"$ref":"#/$defs/AuthoringTargetHandle"},"standard":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"ApplicationNextOperation":{"type":"object","additionalProperties":false,"required":["operation","snapshot"],"properties":{"operation":{"enum":["read","related","routing_facts","route","query","inspect"]},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"target":{"$ref":"#/$defs/CanonicalId"},"handle":{"$ref":"#/$defs/SnapshotChildHandle"}}},"ApplicationRejectedResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","code","outcome","message","next_operations"],"properties":{"kind":{"const":"application-rejected-result"},"purpose":{"const":"application"},"code":{"enum":["APPLICATION.CONTENT_UNAVAILABLE","APPLICATION.INPUT_INVALID","APPLICATION.OPERATION_UNAVAILABLE","APPLICATION.INTERNAL_UNAVAILABLE","APPLICATION.UNSUPPORTED_CAPTURE","APPLICATION.RESULT_LIMIT","APPLICATION.UNKNOWN_GROUP"]},"outcome":{"enum":["invalid","unsupported","unavailable"]},"message":{"type":"string"},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}},"input_feedback":{"$ref":"#/$defs/InputFeedback"},"relationship_groups":{"$ref":"#/$defs/RelationshipGroupsResult"}}},"ApplicationPolicy":{"type":"object","additionalProperties":false,"required":["id","handle","role","level"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"handle":{"$ref":"#/$defs/SnapshotChildHandle"},"role":{"enum":["core","router","topic","workflow","profile","reference","prompt","template","documentation"]},"level":{"enum":["MUST","SHOULD","PROFILE","REFERENCE"]}}},"ApplicationRelationship":{"type":"object","additionalProperties":false,"required":["handle","source","target","relation","groups","direction"],"properties":{"handle":{"$ref":"#/$defs/SnapshotChildHandle"},"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"relation":{"type":"string"},"groups":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"direction":{"enum":["incoming","outgoing"]}}},"ApplicationReadResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","snapshot","policy","content","scope","requires","specializes","next_operations"],"properties":{"kind":{"const":"application-read-result"},"purpose":{"const":"application"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"policy":{"$ref":"#/$defs/ApplicationPolicy"},"content":{"type":"string"},"scope":{"$ref":"#/$defs/ReviewScope"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"related":{"type":"array","items":{"$ref":"#/$defs/ApplicationRelationship"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}}}},"ApplicationRelatedResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","snapshot","target","relationships","next_operations"],"properties":{"kind":{"const":"application-related-result"},"purpose":{"const":"application"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"target":{"$ref":"#/$defs/CanonicalId"},"relationships":{"type":"array","items":{"$ref":"#/$defs/ApplicationRelationship"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}}}},"ApplicationReadingEntry":{"type":"object","additionalProperties":false,"required":["target","scope","authority","state"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"scope":{"$ref":"#/$defs/ReviewScope"},"authority":{"enum":["normative","contextual"]},"state":{"const":"selected"}}},"ApplicationQuestion":{"type":"object","additionalProperties":false,"required":["fact"],"properties":{"fact":{"$ref":"#/$defs/AuthoredRoutingFact"}}},"ApplicationRouteResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","snapshot","status","reading_plan","unresolved_questions","next_operations"],"properties":{"kind":{"const":"application-route-result"},"purpose":{"const":"application"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"status":{"enum":["complete","needs-facts"]},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ApplicationReadingEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/ApplicationQuestion"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}},"content":{"$ref":"#/$defs/ApplicationRoutedContentPage"}}},"ApplicationRoutingFactsResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","snapshot","facts","next_operations"],"properties":{"kind":{"const":"application-routing-facts-result"},"purpose":{"const":"application"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"facts":{"type":"array","items":{"$ref":"#/$defs/AuthoredRoutingFact"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}}}},"ApplicationReadCall":{"type":"object","additionalProperties":false,"required":["target"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"detail":{"enum":["compact","full"]}}},"ApplicationReadRequest":{"type":"object","additionalProperties":false,"required":["kind","target"],"properties":{"kind":{"const":"read"},"target":{"$ref":"#/$defs/CanonicalId"},"detail":{"enum":["compact","full"]}}},"ApplicationQueryRequest":{"oneOf":[{"$ref":"#/$defs/RouteRequest"},{"$ref":"#/$defs/ApplicationReadRequest"},{"$ref":"#/$defs/RelatedRequest"}]},"ApplicationQueryCall":{"type":"object","additionalProperties":false,"required":["snapshot","request"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"request":{"$ref":"#/$defs/ApplicationQueryRequest"}}},"ApplicationInspectCall":{"type":"object","additionalProperties":false,"required":["handle"],"properties":{"handle":{"$ref":"#/$defs/SnapshotChildHandle"}}},"AuthoredDecisionProvenance":{"type":"object","additionalProperties":false,"required":["id","subject","origin","rationale","evidence"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"subject":{"$ref":"#/$defs/CanonicalId"},"origin":{"enum":["documented-original","reconstructed-history","current-justification","unrecorded"]},"rationale":{"type":"string"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"}},"assumptions":{"type":"array","items":{"type":"string"}},"limits":{"type":"array","items":{"type":"string"}},"alternatives":{"type":"array","items":{"type":"string"}},"reconsideration":{"type":"array","items":{"type":"string"}},"supersedes":{"type":"array","items":{"type":"string"}}}},"DecisionProvenanceRecord":{"type":"object","additionalProperties":false,"required":["id","subject","origin","rationale","evidence","assumptions","limits","alternatives","reconsideration","supersedes","subject_binding","retired"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"subject":{"$ref":"#/$defs/CanonicalId"},"origin":{"enum":["documented-original","reconstructed-history","current-justification","unrecorded"]},"rationale":{"type":"string"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"}},"assumptions":{"type":"array","items":{"type":"string"}},"limits":{"type":"array","items":{"type":"string"}},"alternatives":{"type":"array","items":{"type":"string"}},"reconsideration":{"type":"array","items":{"type":"string"}},"supersedes":{"type":"array","items":{"type":"string"}},"subject_binding":{"$ref":"#/$defs/Digest"},"retired":{"type":"boolean"}}},"ApplicationExposureState":{"enum":["unreviewed","current","needs-review"]},"ProvenanceReadResult":{"type":"object","additionalProperties":false,"required":["kind","authority","record","state","next_operations"],"properties":{"kind":{"const":"provenance-read-result"},"authority":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/ProposalRevisionHandle"}]},"record":{"$ref":"#/$defs/DecisionProvenanceRecord"},"state":{"enum":["current","needs-review","retired"]},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}}}},"OperationalReadResult":{"type":"object","additionalProperties":false,"required":["kind","authority","target","canonical_id","role","content","application_exposure","next_operations"],"properties":{"kind":{"const":"operational-read-result"},"authority":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/ProposalRevisionHandle"}]},"target":{"$ref":"#/$defs/AuthoringTargetHandle"},"canonical_id":{"$ref":"#/$defs/CanonicalId"},"role":{"enum":["prompt","template","documentation"]},"content":{"type":"string"},"application_exposure":{"$ref":"#/$defs/ApplicationExposureState"},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}}}},"PutDecisionProvenanceEdit":{"type":"object","additionalProperties":false,"required":["kind","record"],"properties":{"kind":{"const":"put-provenance"},"record":{"$ref":"#/$defs/AuthoredDecisionProvenance"}}},"RetireDecisionProvenanceEdit":{"type":"object","additionalProperties":false,"required":["kind","id"],"properties":{"kind":{"const":"retire-provenance"},"id":{"$ref":"#/$defs/CanonicalId"}}},"ApproveApplicationContentEdit":{"type":"object","additionalProperties":false,"required":["kind","target"],"properties":{"kind":{"const":"approve-application-content"},"target":{"oneOf":[{"$ref":"#/$defs/CanonicalId"},{"$ref":"#/$defs/AuthoringTargetHandle"}]}}},"WithdrawApplicationContentEdit":{"type":"object","additionalProperties":false,"required":["kind","target"],"properties":{"kind":{"const":"withdraw-application-content"},"target":{"oneOf":[{"$ref":"#/$defs/CanonicalId"},{"$ref":"#/$defs/AuthoringTargetHandle"}]}}},"ReviseOperationalArtifactEdit":{"type":"object","additionalProperties":false,"required":["kind","target","title","body"],"properties":{"kind":{"const":"revise-operational-artifact"},"target":{"oneOf":[{"$ref":"#/$defs/CanonicalId"},{"$ref":"#/$defs/AuthoringTargetHandle"}]},"title":{"$ref":"#/$defs/NonEmptyString"},"body":{"type":"string"}}},"PolicyScopeUpdate":{"type":"object","additionalProperties":false,"required":["policy","heading_path","semantics"],"properties":{"policy":{"$ref":"#/$defs/CanonicalId"},"heading_path":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/NonEmptyString"}},"semantics":{"$ref":"#/$defs/PolicySemanticIntent"}}},"ReadManyItem":{"type":"object","required":["target"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"include_routing":{"type":"boolean"},"include_coverage":{"type":"boolean","description":"Include current repository attestation status for registered policy units in this read scope."},"detail":{"enum":["compact","full"],"description":"Compact preserves exact policy and essential authority; full includes all relationship rows."}},"additionalProperties":false},"ReadManyCall":{"type":"object","additionalProperties":false,"required":["snapshot","items"],"description":"Read 1–32 selected items from one explicit snapshot, preserving order. The complete JSON result is limited to 2 MiB; any failed item rejects the entire request.","properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"items":{"type":"array","minItems":1,"maxItems":32,"uniqueItems":true,"items":{"$ref":"#/$defs/ReadManyItem"}}}},"ReadManyResult":{"type":"object","additionalProperties":false,"required":["kind","snapshot","items"],"properties":{"kind":{"const":"read-many-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"items":{"type":"array","minItems":1,"maxItems":32,"items":{"oneOf":[{"$ref":"#/$defs/CompactReadResult"},{"$ref":"#/$defs/ReadResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/OperationalReadResult"}]}}}},"ApplicationReadManyItem":{"type":"object","additionalProperties":false,"required":["target"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"detail":{"enum":["compact","full"]}}},"ApplicationReadManyCall":{"type":"object","additionalProperties":false,"required":["snapshot","items"],"description":"Read 1–32 selected items from one explicit snapshot, preserving order. The complete JSON result is limited to 2 MiB; any failed item rejects the entire request.","properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"items":{"type":"array","minItems":1,"maxItems":32,"uniqueItems":true,"items":{"$ref":"#/$defs/ApplicationReadManyItem"}}}},"ApplicationReadManyResult":{"type":"object","additionalProperties":false,"required":["kind","snapshot","items","purpose"],"properties":{"kind":{"const":"application-read-many-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"items":{"type":"array","minItems":1,"maxItems":32,"items":{"oneOf":[{"$ref":"#/$defs/ApplicationReadResult"}]}},"purpose":{"const":"application"}}},"RegisterConsumerEdit":{"type":"object","additionalProperties":false,"required":["kind","consumer","path","artifact_kind","authority"],"properties":{"kind":{"const":"register-consumer"},"consumer":{"$ref":"#/$defs/CanonicalId"},"path":{"$ref":"#/$defs/NonEmptyString"},"artifact_kind":{"enum":["fixture","documentation","implementation-artifact","prompt","template"]},"authority":{"enum":["evidence","projection"]}},"description":"Register an existing tracked consumer within this proposal. The Engine captures original-revision bytes; use separate policy relationships to declare consumers and review obligations."},"PreviewApplicationCall":{"type":"object","additionalProperties":false,"required":["revision","request"],"properties":{"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"request":{"$ref":"#/$defs/ApplicationQueryRequest"}},"description":"Authoring-only inspection of an exact draft through application qualification and filtering; this observation neither publishes nor grants ordinary application access."},"CandidateApplicationNextOperation":{"type":"object","additionalProperties":false,"required":["operation","revision","request"],"properties":{"operation":{"const":"preview_application"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"request":{"$ref":"#/$defs/ApplicationQueryRequest"}}},"CandidateApplicationPolicy":{"type":"object","additionalProperties":false,"required":["id","role","level"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"role":{"enum":["core","router","topic","workflow","profile","reference","prompt","template","documentation"]},"level":{"enum":["MUST","SHOULD","PROFILE","REFERENCE"]}}},"CandidateApplicationRelationship":{"type":"object","additionalProperties":false,"required":["source","target","relation","groups","direction"],"properties":{"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"relation":{"type":"string"},"groups":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"direction":{"enum":["incoming","outgoing"]}}},"CandidateApplicationReadResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","policy","content","scope","requires","specializes","next_operations","revision"],"properties":{"kind":{"const":"candidate-application-read-result"},"purpose":{"const":"application"},"policy":{"$ref":"#/$defs/CandidateApplicationPolicy"},"content":{"type":"string"},"scope":{"$ref":"#/$defs/ReviewScope"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"related":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationRelationship"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationNextOperation"}},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}}},"CandidateApplicationRelatedResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","target","relationships","next_operations","revision"],"properties":{"kind":{"const":"candidate-application-related-result"},"purpose":{"const":"application"},"target":{"$ref":"#/$defs/CanonicalId"},"relationships":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationRelationship"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationNextOperation"}},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}}},"CandidateApplicationRouteResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","status","reading_plan","unresolved_questions","next_operations","revision"],"properties":{"kind":{"const":"candidate-application-route-result"},"purpose":{"const":"application"},"status":{"enum":["complete","needs-facts"]},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ApplicationReadingEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/ApplicationQuestion"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationNextOperation"}},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}}},"CandidateApplicationRejectedResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","code","outcome","message","next_operations","revision"],"properties":{"kind":{"const":"candidate-application-rejected-result"},"purpose":{"const":"application"},"code":{"enum":["APPLICATION.CONTENT_UNAVAILABLE","APPLICATION.INPUT_INVALID","APPLICATION.OPERATION_UNAVAILABLE","APPLICATION.INTERNAL_UNAVAILABLE","APPLICATION.UNSUPPORTED_CAPTURE","APPLICATION.RESULT_LIMIT"]},"outcome":{"enum":["invalid","unsupported","unavailable"]},"message":{"type":"string"},"next_operations":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationNextOperation"}},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}}},"PreviewApplicationResult":{"oneOf":[{"$ref":"#/$defs/CandidateApplicationReadResult"},{"$ref":"#/$defs/CandidateApplicationRelatedResult"},{"$ref":"#/$defs/CandidateApplicationRouteResult"},{"$ref":"#/$defs/CandidateApplicationRejectedResult"}]},"ResolveManyCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/AnalysisHandle"},"submissions":{"type":"array","items":{"$ref":"#/$defs/Submission"},"minItems":1,"maxItems":128},"detail":{"enum":["compact","full"]}},"required":["context","submissions"],"description":"Resolve ordered decisions bound to one original analysis. Validate every item before publishing a final immutable successor; an invalid batch persists no intermediate decisions."},"WorkflowSection":{"enum":["pending_obligations","obligations","fact_requirements","coverage_certificates","dispositions","fact_observations","reading_plan","changed_units"]},"WorkflowAnalysisSummary":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"workflow-analysis-summary"},"status":{"enum":["needs-action","complete"]},"required_obligations":{"type":"integer","minimum":0},"pending_facts":{"type":"integer","minimum":0},"sections":{"type":"array","items":{"$ref":"#/$defs/WorkflowSectionCount"}},"details":{"$ref":"#/$defs/WorkflowDetailsLink"}},"required":["kind","status","required_obligations","pending_facts","sections","details"],"description":"Counts for the enclosing immutable Analysis context. Observation remains summary-only; successful compact pending mutations additionally return a bounded work page."},"WorkflowSectionCount":{"type":"object","additionalProperties":false,"properties":{"section":{"$ref":"#/$defs/WorkflowSection"},"count":{"type":"integer","minimum":0}},"required":["section","count"]},"WorkflowDetailsLink":{"type":"object","additionalProperties":false,"properties":{"operation":{"const":"workflow_details"}},"required":["operation"],"description":"Supply the enclosing WorkflowResult Analysis context as analysis and explicitly select a section."},"WorkflowDetailsCall":{"type":"object","additionalProperties":false,"properties":{"analysis":{"$ref":"#/$defs/AnalysisHandle"},"section":{"$ref":"#/$defs/WorkflowSection"},"offset":{"type":"integer","minimum":0},"limit":{"type":"integer","minimum":1,"maximum":16},"observation":{"$ref":"#/$defs/Digest"},"detail":{"enum":["compact","full"],"description":"Compact is byte-bounded; full explicitly retrieves one whole record without the compact byte cap."}},"required":["analysis","section"],"description":"Read a section of an immutable historical Analysis. Compact pages (default eight items) contain up to 16 whole records and 64 KiB of result JSON, returning fewer items when needed. An oversized record returns an explicit full-detail retry. detail=full retrieves one complete record (limit omitted or 1) without the compact byte cap; choose it only when the client can receive that payload. Continuations bind the Analysis, section and projected contents. Decision and publication operations check current evidence and authorization. A full-record response resumes compact paging in its next request."},"WorkflowDetailItem":{"oneOf":[{"$ref":"#/$defs/Obligation"},{"$ref":"#/$defs/FactRequirementWork"},{"$ref":"#/$defs/CoverageCertificate"},{"$ref":"#/$defs/DispositionRecord"},{"$ref":"#/$defs/FactObservation"},{"$ref":"#/$defs/ReadingPlanEntry"},{"$ref":"#/$defs/ChangedPolicyUnit"},{"$ref":"#/$defs/WorkflowObligationWork"}]},"WorkflowDetailsResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"workflow-details-result"},"analysis":{"$ref":"#/$defs/AnalysisHandle"},"section":{"$ref":"#/$defs/WorkflowSection"},"observation":{"$ref":"#/$defs/Digest"},"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","items":{"$ref":"#/$defs/WorkflowDetailItem"},"maxItems":16},"next":{"$ref":"#/$defs/WorkflowDetailsCall"}},"required":["kind","analysis","section","observation","offset","total","items"],"description":"Whole records from an immutable Analysis section. Compact may return fewer than limit to respect 64 KiB. Full returns at most one complete record and may exceed 64 KiB. Follow next exactly; observation and total are independent of page size and detail mode."},"RuntimeInfoCall":{"type":"object","additionalProperties":false,"properties":{"expected_catalog":{"$ref":"#/$defs/Digest"}},"required":[]},"RuntimeInfoResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"runtime-info-result"},"purpose":{"enum":["application","authoring"]},"interface_version":{"type":"integer","minimum":1},"implementation_version":{"type":"string","minLength":1},"instance_id":{"type":"string","minLength":1},"implementation_digest":{"$ref":"#/$defs/Digest"},"catalog_digest":{"$ref":"#/$defs/Digest"},"schema_digest":{"$ref":"#/$defs/Digest"},"installation_state":{"enum":["current","restart-required","unavailable"]},"client_catalog_state":{"enum":["unspecified","matches","differs"]},"action":{"enum":["reuse","restart-and-reconnect","refresh-tools","check-installation"]}},"required":["kind","purpose","interface_version","implementation_version","instance_id","implementation_digest","catalog_digest","schema_digest","installation_state","client_catalog_state","action"]},"WorkflowObligationWork":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"workflow-obligation-work"},"obligation":{"$ref":"#/$defs/Obligation"},"work":{"$ref":"#/$defs/AnalysisChildHandle"}},"required":["kind","obligation","work"]},"WorkflowDetailsNextOperation":{"type":"object","additionalProperties":false,"properties":{"operation":{"const":"workflow_details"},"request_kind":{"const":"workflow-details"},"request":{"$ref":"#/$defs/WorkflowDetailsCall"}},"required":["operation","request_kind","request"],"description":"An explicit historical detail retrieval alternative. Invoke operation with request; do not automatically select size-unbounded full detail."},"WorkflowDetailsSelection":{"type":"object","additionalProperties":false,"properties":{"section":{"$ref":"#/$defs/WorkflowSection"},"offset":{"type":"integer","minimum":0},"limit":{"type":"integer","minimum":1,"maximum":16},"observation":{"$ref":"#/$defs/Digest"},"detail":{"enum":["compact","full"],"description":"Compact is byte-bounded; full explicitly retrieves one whole record without the compact byte cap."}},"required":["section"],"description":"A workflow_details selection relative to the enclosing WorkflowResult Analysis context. Add analysis from that context when invoking; preserve every returned selection field."},"WorkflowWorkPage":{"type":"object","additionalProperties":false,"description":"First actionable section of a successful compact pending mutation, bound to the enclosing Analysis context. Facts precede obligations. Up to eight whole items and 64 KiB of page JSON; next is a relative workflow_details selection. Work handles retain their complete authority.","properties":{"kind":{"const":"workflow-work-page"},"section":{"enum":["fact_requirements","pending_obligations"]},"observation":{"$ref":"#/$defs/Digest"},"offset":{"const":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","maxItems":8,"items":{"oneOf":[{"$ref":"#/$defs/FactRequirementWork"},{"$ref":"#/$defs/WorkflowObligationWork"}]}},"next":{"$ref":"#/$defs/WorkflowDetailsSelection"}},"required":["kind","section","observation","offset","total","items"]},"WorkflowWorkDeferred":{"type":"object","additionalProperties":false,"description":"The mutation succeeded but its first complete work record exceeds the compact page budget. Preserve the enclosing context and counts; request explicitly selects that exact full record without the compact byte cap.","properties":{"kind":{"const":"workflow-work-deferred"},"code":{"const":"WORKFLOW.RESULT_LIMIT"},"section":{"enum":["fact_requirements","pending_obligations"]},"total":{"type":"integer","minimum":0},"request":{"$ref":"#/$defs/WorkflowDetailsSelection"}},"required":["kind","code","section","total","request"]},"AgentAuthoredDecisionProvenance":{"type":"object","additionalProperties":false,"required":["id","subject","origin","rationale","evidence"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"subject":{"$ref":"#/$defs/CanonicalId"},"origin":{"enum":["documented-original","reconstructed-history","current-justification","unrecorded"]},"rationale":{"type":"string"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"}},"assumptions":{"type":"array","items":{"type":"string"}},"limits":{"type":"array","items":{"type":"string"}},"alternatives":{"type":"array","items":{"type":"string"}},"reconsideration":{"type":"array","items":{"type":"string"}},"supersedes":{"type":"array","items":{"type":"string"}}}},"AgentConsumerDispositionSubmission":{"type":"object","required":["kind","obligation","result","rationale","evidence","fingerprint"],"properties":{"kind":{"const":"consumer-disposition"},"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"result":{"enum":["updated","reviewed-no-change","not-applicable","blocked"]},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"minItems":1},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"AgentCoverageAttestationClaim":{"type":"object","required":["requirement","conclusion","evidence","explicit_exclusions","rationale","auditor_provenance"],"properties":{"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"conclusion":{"const":"complete"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"minItems":1,"uniqueItems":true},"explicit_exclusions":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"uniqueItems":true},"rationale":{"$ref":"#/$defs/NonEmptyString"},"auditor_provenance":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"AgentCoverageAttestationSubmission":{"type":"object","required":["kind","claim"],"properties":{"kind":{"const":"coverage-attestation"},"claim":{"$ref":"#/$defs/AgentCoverageAttestationClaim"}},"additionalProperties":false},"AgentImpactDispositionSubmission":{"type":"object","required":["kind","obligation","result","rationale","evidence","fingerprint"],"properties":{"kind":{"const":"impact-disposition"},"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"result":{"enum":["confirmed","resolved-no-impact","requires-change","blocked"]},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"minItems":1},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"AgentProposeCall":{"type":"object","additionalProperties":false,"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"change_set":{"$ref":"#/$defs/AgentStandardsChangeSet"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["change_set"]},"AgentProvideFactSubmission":{"type":"object","required":["kind","requirement","value","evidence"],"properties":{"kind":{"const":"provide-fact"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"value":{"$ref":"#/$defs/FactValue"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"minItems":1,"uniqueItems":true}},"additionalProperties":false},"AgentPutDecisionProvenanceEdit":{"type":"object","additionalProperties":false,"required":["kind","record"],"properties":{"kind":{"const":"put-provenance"},"record":{"$ref":"#/$defs/AgentAuthoredDecisionProvenance"}}},"AgentRelationshipDisposition":{"type":"object","required":["relationship","disposition","rationale","evidence"],"properties":{"relationship":{"$ref":"#/$defs/RelationshipKey"},"disposition":{"enum":["remove","retarget"]},"replacement_consumer":{"$ref":"#/$defs/RelationshipConsumer"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentResolveManyCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/AnalysisHandle"},"submissions":{"type":"array","items":{"$ref":"#/$defs/AgentSubmission"},"minItems":1,"maxItems":128},"detail":{"enum":["compact","full"]},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["context","submissions"],"description":"Resolve ordered decisions bound to one original analysis. Validate every item before publishing a final immutable successor; an invalid batch persists no intermediate decisions."},"AgentResolveWorkflowCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"submission":{"$ref":"#/$defs/AgentSubmission"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["context","submission"]},"AgentRetirePolicyUnitEdit":{"type":"object","required":["kind","policy","retired_semantic_revision","successors","relationship_dispositions","evidence"],"properties":{"kind":{"const":"retire-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"retired_semantic_revision":{"type":"integer","minimum":1},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"relationship_dispositions":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/AgentRelationshipDisposition"}},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentRetireStandardEdit":{"type":"object","required":["kind","standard","successors","relationship_dispositions","evidence"],"properties":{"kind":{"const":"retire-standard"},"standard":{"$ref":"#/$defs/CanonicalId"},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"relationship_dispositions":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/AgentRelationshipDisposition"}},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentReviewCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"decisions":{"type":"array","minItems":3,"maxItems":3,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentReviewDecision"}},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["context","decisions"]},"AgentReviewDecision":{"type":"object","required":["owner","decision","rationale","evidence"],"properties":{"owner":{"enum":["consumer","impact","audit"]},"decision":{"const":"accept"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentReviseCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"change_set":{"$ref":"#/$defs/AgentStandardsChangeSet"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["context","change_set"]},"AgentStandardEdit":{"oneOf":[{"$ref":"#/$defs/CreateStandardEdit"},{"$ref":"#/$defs/RegisterPolicyUnitEdit"},{"$ref":"#/$defs/ReviseStandardEdit"},{"$ref":"#/$defs/RevisePolicyUnitEdit"},{"$ref":"#/$defs/MovePolicyUnitEdit"},{"$ref":"#/$defs/AgentRetirePolicyUnitEdit"},{"$ref":"#/$defs/AgentRetireStandardEdit"},{"$ref":"#/$defs/ReplaceStandardRelationshipsEdit"},{"$ref":"#/$defs/PutPolicyRelationshipEdit"},{"$ref":"#/$defs/RemovePolicyRelationshipEdit"},{"$ref":"#/$defs/PutRoutingRuleEdit"},{"$ref":"#/$defs/RemoveRoutingRuleEdit"},{"$ref":"#/$defs/PutRoutingFactEdit"},{"$ref":"#/$defs/RemoveRoutingFactEdit"},{"$ref":"#/$defs/AuditPolicyUnitEdit"},{"$ref":"#/$defs/RewriteNavigationIndexEdit"},{"$ref":"#/$defs/AgentPutDecisionProvenanceEdit"},{"$ref":"#/$defs/RetireDecisionProvenanceEdit"},{"$ref":"#/$defs/ApproveApplicationContentEdit"},{"$ref":"#/$defs/WithdrawApplicationContentEdit"},{"$ref":"#/$defs/ReviseOperationalArtifactEdit"},{"$ref":"#/$defs/RegisterConsumerEdit"}]},"AgentStandardsChangePurpose":{"type":"object","required":["summary","rationale","evidence"],"properties":{"summary":{"$ref":"#/$defs/NonEmptyString"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentStandardsChangeSet":{"type":"object","required":["purpose","edits"],"properties":{"purpose":{"$ref":"#/$defs/AgentStandardsChangePurpose"},"edits":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentStandardEdit"}}},"additionalProperties":false},"AgentSubmission":{"oneOf":[{"$ref":"#/$defs/AgentProvideFactSubmission"},{"$ref":"#/$defs/AgentConsumerDispositionSubmission"},{"$ref":"#/$defs/AgentImpactDispositionSubmission"},{"$ref":"#/$defs/AgentCoverageAttestationSubmission"}]},"EvidenceUse":{"type":"object","required":["evidence_ref"],"properties":{"evidence_ref":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false,"description":"Select one exact reference from the evidence table of this request only. This is not an authorization or an attestation."},"AgentEvidenceReference":{"oneOf":[{"$ref":"#/$defs/EvidenceReference"},{"$ref":"#/$defs/EvidenceUse"}]},"RequestEvidenceTable":{"type":"object","additionalProperties":{"$ref":"#/$defs/EvidenceReference"},"description":"At most 128 request-local named exact references. Every entry must be used; each evidence_ref must name an entry. Expanded native validation and all ordinary evidence checks still apply."},"RouteContentSelection":{"type":"object","properties":{"offset":{"type":"integer","minimum":0,"description":"Default zero. A nonzero offset requires an explicit snapshot from the same route."},"limit":{"type":"integer","minimum":1,"maximum":32,"description":"Maximum whole policy reads in this page; default eight. Byte pressure may return fewer."}},"additionalProperties":false},"RoutedContentPage":{"type":"object","required":["offset","total","items"],"properties":{"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","maxItems":32,"items":{"oneOf":[{"$ref":"#/$defs/CompactReadResult"},{"$ref":"#/$defs/ReadResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/OperationalReadResult"}]}},"next":{"$ref":"#/$defs/RouteCall"}},"additionalProperties":false,"description":"Exact compact reads of selected targets in Router order. Total counts selected targets, not unresolved applicability. Follow next unchanged for the remaining page."},"ApplicationRoutedContentPage":{"type":"object","required":["offset","total","items"],"properties":{"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","maxItems":32,"items":{"$ref":"#/$defs/ApplicationReadResult"}},"next":{"$ref":"#/$defs/RouteCall"}},"additionalProperties":false,"description":"Exact compact reads of selected targets in Router order. Total counts selected targets, not unresolved applicability. Follow next unchanged for the remaining page."},"DescribeInputCall":{"type":"object","additionalProperties":false,"properties":{"operation":{"type":"string","minLength":1,"description":"An operation published in this running catalog."},"selector":{"type":"string","pattern":"^[A-Za-z][A-Za-z0-9]*$","description":"A returned definition name (or the name in a schema $ref). Omit for the operation input root."},"expected_catalog":{"$ref":"#/$defs/Digest"},"offset":{"type":"integer","minimum":0,"description":"Record offset within the selected closure. Continue with the returned next request."},"limit":{"type":"integer","minimum":1,"maximum":16,"description":"Maximum whole schema records in this page; default 8. Byte pressure may return fewer."}},"required":["operation"]},"InputSchemaRecord":{"type":"object","additionalProperties":false,"properties":{"name":{"type":"string","minLength":1},"schema_json":{"type":"string","minLength":1,"description":"Exact JSON Schema definition serialized as a JSON document; $refs name other returned/selectable definitions. Not a standalone validator without its closure."}},"required":["name","schema_json"]},"InputContractResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"input-contract-result"},"purpose":{"enum":["application","authoring"]},"interface_version":{"type":"integer","minimum":1},"catalog_digest":{"$ref":"#/$defs/Digest"},"operation":{"type":"string","minLength":1},"root":{"type":"string","minLength":1},"selector":{"type":"string","minLength":1},"dialect":{"const":"https://json-schema.org/draft/2020-12/schema"},"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":1},"records":{"type":"array","maxItems":16,"items":{"$ref":"#/$defs/InputSchemaRecord"}},"next":{"$ref":"#/$defs/DescribeInputCall"}},"required":["kind","purpose","interface_version","catalog_digest","operation","root","selector","dialect","offset","total","records"]},"InputContractRejectedResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"input-contract-rejected-result"},"purpose":{"enum":["application","authoring"]},"code":{"enum":["INPUT_DISCOVERY.INVALID_ARGUMENTS","INPUT_DISCOVERY.OPERATION_UNAVAILABLE","INPUT_DISCOVERY.CATALOG_CHANGED","INPUT_DISCOVERY.SELECTION_INVALID","INPUT_DISCOVERY.RESULT_LIMIT"]},"outcome":{"enum":["invalid","unavailable","unsupported"]},"message":{"type":"string","minLength":1},"input_feedback":{"$ref":"#/$defs/InputFeedback"}},"required":["kind","purpose","code","outcome","message"]},"InputIssue":{"type":"object","additionalProperties":false,"properties":{"instance_pointer":{"type":"string","description":"JSON Pointer to the invalid field; non-exact locations redact dynamic keys as * or use the root."},"location_exact":{"type":"boolean"},"keyword":{"type":"string"},"message":{"type":"string"}},"required":["instance_pointer","location_exact","keyword","message"]},"InputFeedback":{"type":"object","additionalProperties":false,"properties":{"issues":{"type":"array","maxItems":8,"items":{"$ref":"#/$defs/InputIssue"}},"truncated":{"type":"boolean","description":"Additional diagnostic detail was omitted due to a work, item or byte bound."},"describe_input":{"$ref":"#/$defs/DescribeInputCall"}},"required":["issues","truncated","describe_input"]},"RelationshipGroupsCall":{"type":"object","additionalProperties":false,"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"offset":{"type":"integer","minimum":0,"description":"Continue with the exact snapshot and offset returned by next. Nonzero offsets require a snapshot."},"limit":{"type":"integer","minimum":1,"maximum":32,"description":"Whole records per page, default 8; byte pressure may return fewer."}},"required":[]},"RelationshipGroup":{"type":"object","additionalProperties":false,"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"description":{"type":"string"},"traversal_directions":{"type":"array","minItems":1,"uniqueItems":true,"items":{"enum":["incoming","outgoing"]},"description":"Directions permitted by this group for traversals; adjacency queries remain distinct."},"transitive":{"type":"boolean","description":"Whether the group permits transitive traversal."}},"required":["id","description","traversal_directions","transitive"]},"RelationshipGroupsResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"relationship-groups-result"},"purpose":{"enum":["application","authoring"]},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","maxItems":32,"items":{"$ref":"#/$defs/RelationshipGroup"}},"next":{"$ref":"#/$defs/RelationshipGroupsCall"}},"required":["kind","purpose","snapshot","offset","total","items"]},"CompactRouteResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"compact-route-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"status":{"enum":["complete","needs-facts"]},"facts":{"$ref":"#/$defs/RoutingFactAssertions"},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/RoutingQuestion"}},"unresolved_policy_count":{"type":"integer","minimum":0},"explanation":{"$ref":"#/$defs/RouteCall"},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"},"content":{"$ref":"#/$defs/RoutedContentPage"}},"required":["kind","snapshot","status","facts","reading_plan","unresolved_questions","unresolved_policy_count","explanation","next_operations"]},"DescribeOutputCall":{"type":"object","additionalProperties":false,"properties":{"operation":{"type":"string","minLength":1,"description":"An operation published in this running catalog."},"selector":{"type":"string","pattern":"^[A-Za-z][A-Za-z0-9]*$","description":"A returned output definition name. Omit for the complete operation result algebra."},"expected_catalog":{"$ref":"#/$defs/Digest"},"offset":{"type":"integer","minimum":0,"description":"Record offset within the selected closure. Continue with the returned next request."},"limit":{"type":"integer","minimum":1,"maximum":16,"description":"Maximum whole schema records in this page; default 8. Byte pressure may return fewer."}},"required":["operation"]},"OutputSchemaRecord":{"type":"object","additionalProperties":false,"properties":{"name":{"type":"string","minLength":1},"schema_json":{"type":"string","minLength":1,"description":"Exact JSON Schema definition serialized as a JSON document; $refs name other returned/selectable definitions. Not a standalone validator without its closure."}},"required":["name","schema_json"]},"OutputContractResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"output-contract-result"},"purpose":{"enum":["application","authoring"]},"interface_version":{"type":"integer","minimum":1},"catalog_digest":{"$ref":"#/$defs/Digest"},"operation":{"type":"string","minLength":1},"selector":{"type":"string","minLength":1},"dialect":{"const":"https://json-schema.org/draft/2020-12/schema"},"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":1},"records":{"type":"array","maxItems":16,"items":{"$ref":"#/$defs/OutputSchemaRecord"}},"next":{"$ref":"#/$defs/DescribeOutputCall"},"roots":{"type":"array","minItems":1,"uniqueItems":true,"items":{"type":"string","minLength":1}},"root_schema_json":{"type":"string","minLength":1,"description":"Exact operation result schema without $defs. Combine with all result-root definition pages for validation; schema_digest binds the full schema."},"schema_digest":{"$ref":"#/$defs/Digest"}},"required":["kind","purpose","interface_version","catalog_digest","operation","dialect","offset","total","records","roots","root_schema_json","schema_digest"]},"OutputContractRejectedResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"output-contract-rejected-result"},"purpose":{"enum":["application","authoring"]},"code":{"enum":["OUTPUT_DISCOVERY.INVALID_ARGUMENTS","OUTPUT_DISCOVERY.OPERATION_UNAVAILABLE","OUTPUT_DISCOVERY.CATALOG_CHANGED","OUTPUT_DISCOVERY.SELECTION_INVALID","OUTPUT_DISCOVERY.RESULT_LIMIT"]},"outcome":{"enum":["invalid","unavailable","unsupported"]},"message":{"type":"string","minLength":1},"input_feedback":{"$ref":"#/$defs/InputFeedback"}},"required":["kind","purpose","code","outcome","message"]},"RoutingFactAssertion":{"oneOf":[{"type":"boolean"},{"type":"null"},{"type":"string"},{"type":"array","items":{"type":"string"},"uniqueItems":true},{"type":"object","additionalProperties":false,"required":["state"],"properties":{"state":{"enum":["known-absent","unknown"]}}}]},"RoutingFactAssertions":{"type":"object","additionalProperties":{"$ref":"#/$defs/RoutingFactAssertion"}}}}') -DEFINITION_METADATA = freeze_json({'ActiveSnapshotSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'lifecycle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'created_at': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentAuthoredDecisionProvenance': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'origin': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'assumptions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limits': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'alternatives': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reconsideration': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'supersedes': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentConsumerDispositionSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentCoverageAttestationClaim': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'conclusion': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'explicit_exclusions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'auditor_provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentCoverageAttestationSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'claim': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentEvidenceReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AgentImpactDispositionSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentProposeCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentProvideFactSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentPutDecisionProvenanceEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'record': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentRelationshipDisposition': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'disposition': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'replacement_consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentResolveManyCall': {'title': None, 'description': 'Resolve ordered decisions bound to one original analysis. Validate every item before publishing a final immutable successor; an invalid batch persists no intermediate decisions.', 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submissions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentResolveWorkflowCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submission': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentRetirePolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retired_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentRetireStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentReviewCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decisions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentReviewDecision': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentReviseCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rules': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AgentStandardsChangePurpose': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentStandardsChangeSet': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edits': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AllExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expressions': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AlwaysExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisChildArtifact': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AnalysisChildHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'child_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'child_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisChildInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'artifact': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisContext': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subjects': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_proposals': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisExecutionContractView': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'authorization_authority_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'providers': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AnalysisInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisMaterialHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AnalysisRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'base_snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_proposals': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prior_analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'contract_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisState': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'base_snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_reference': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_proposals': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_observations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage_attestations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_records': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'domain_contracts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'execution_contracts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'contract_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalyzeCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'AnalyzeProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnyExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expressions': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicabilityExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ApplicationExposureState': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ApplicationHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ApplicationInspectCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationPolicy': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'level': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationPublicationReceipt': {'title': None, 'description': 'Durable application identity and exact candidate facts, separate from the fresh target observation.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'candidate_commit': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'candidate_tree': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target_ref': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expected_predecessor': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'durable_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target_observation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationQueryCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationQueryRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ApplicationQuestion': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadManyCall': {'title': None, 'description': 'Read 1–32 selected items from one explicit snapshot, preserving order. The complete JSON result is limited to 2 MiB; any failed item rejects the entire request.', 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadManyItem': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadManyResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'related': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadingEntry': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRecoveryRequiredResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checkout': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'details': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_feedback': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_groups': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRelatedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationships': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRelationship': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRoutedContentPage': {'title': None, 'description': 'Exact compact reads of selected targets in Router order. Total counts selected targets, not unresolved applicability. Follow next unchanged for the remaining page.', 'has_default': False, 'default': None, 'properties': {'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRoutingFactsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplyCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ApplyProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplyProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checkout': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApproveApplicationContentEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuditPolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthoredDecisionProvenance': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'origin': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'assumptions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limits': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'alternatives': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reconsideration': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'supersedes': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthoredRoutingFact': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'type': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'nullable': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'values': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'aliases': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'meaning': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prompt': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthoredRoutingRule': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'condition': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthoringTargetHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthorizationId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AuthorizationRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'reference': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'issuer_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'principal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'action': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revocation_authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revocation_authority_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revocation_evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthorizationReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'issuer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'capability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationPolicy': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'level': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'related': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationRejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationRelatedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationships': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationRelationship': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CanonicalId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'CanonicalModuleDeclaration': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'level': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applies_when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'does_not_apply_when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ChangeDescriptor': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_ids': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_ids': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_module': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_module': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ChangePolicySemantics': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'intent': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ChangedPolicyUnit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'classification': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_representation_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_representation_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_structural_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_structural_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ChildId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'CompactReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application_exposure': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CompactRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_policy_count': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'explanation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CompleteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changed_units': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage_certificates': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_observations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'completion': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CompletionProof': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'required_coverage_subjects': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'certificate_subjects': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reached_consumer_obligations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'disposition_obligations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'required_fact_requirements': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observed_fact_requirements': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'non_consumer_obligations_resolved': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability_resolved': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_valid': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_valid': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ConsumerDispositionSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ConsumerReviewContract': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'permitted_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_capability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ConsumerReviewObligationReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ContainsExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageAttestation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'conclusion': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'explicit_exclusions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'auditor_provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageAttestationClaim': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'conclusion': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'explicit_exclusions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'auditor_provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageAttestationSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'claim': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageAuditAuthority': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'issuer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'principal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_id': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageCertificate': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'horizon_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_digests': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_schema_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageRequirement': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_kinds': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'horizon': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'required_evidence_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'base_snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateSnapshotCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateSnapshotResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_units': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DecisionDependency': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'class': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'identity': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DecisionFingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'decision_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decision_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dependencies': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DecisionProvenanceRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'origin': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'assumptions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limits': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'alternatives': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reconsideration': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'supersedes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject_binding': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retired': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DeleteSnapshotCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DeleteSnapshotResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purge_deadline': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DescribeInputCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': 'An operation published in this running catalog.', 'has_default': False, 'default': None}, 'selector': {'title': None, 'description': 'A returned definition name (or the name in a schema $ref). Omit for the operation input root.', 'has_default': False, 'default': None}, 'expected_catalog': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': 'Record offset within the selected closure. Continue with the returned next request.', 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': 'Maximum whole schema records in this page; default 8. Byte pressure may return fewer.', 'has_default': False, 'default': None}}}, 'DescribeOutputCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': 'An operation published in this running catalog.', 'has_default': False, 'default': None}, 'selector': {'title': None, 'description': 'A returned output definition name. Omit for the complete operation result algebra.', 'has_default': False, 'default': None}, 'expected_catalog': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': 'Record offset within the selected closure. Continue with the returned next request.', 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': 'Maximum whole schema records in this page; default 8. Byte pressure may return fewer.', 'has_default': False, 'default': None}}}, 'Digest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'DispositionRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DomainContractReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EdgeId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'EngineCertificateRetirement': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EqualsExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceCheckRetirement': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'suite': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'check': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceConsumerRegistration': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'path': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'artifact_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_policies': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceMaintenancePlan': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'retire_engine_certificates': {'title': None, 'description': 'Explicitly retire exact registered Engine-issued certificates by subject and requirement; preserve normative policy and consumer registrations.', 'has_default': False, 'default': None}, 'prune_stale_certificates': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retire_suites': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retire_checks': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retire_inputs': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'suite_descriptions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'replacement_evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'replacement_evidence_rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_updates': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer_registrations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unregister_policy_subjects': {'title': None, 'description': 'Remove selected review-subject registrations and their source relationships while preserving normative Markdown.', 'has_default': False, 'default': None}}}, 'EvidenceReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provider_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provider_contract_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceRelationshipUpdate': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'source_policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceSuiteDescription': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'suite': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'description': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceUse': {'title': None, 'description': 'Select one exact reference from the evidence table of this request only. This is not an authorization or an attestation.', 'has_default': False, 'default': None, 'properties': {'evidence_ref': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ExistsExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FactObservation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provider': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FactRequirement': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_contract_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'answer_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_capability': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FactRequirementId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'FactRequirementWork': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prompt': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dependent_programs': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FactSet': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'FactValue': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'FactValueContract': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'type': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'states': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'nullable': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'values': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FindProposalsCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'after': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': None, 'has_default': True, 'default': 50}}}, 'FindProposalsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposals': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'continuation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FindSnapshotsCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'lifecycle': {'title': None, 'description': None, 'has_default': True, 'default': 'active'}, 'after': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': None, 'has_default': True, 'default': 50}}}, 'FindSnapshotsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshots': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'continuation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FocusedQueryNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'GeneralSelectionReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edge': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'question': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'GitObjectId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ImpactDispositionSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ImpactTraceId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ImpactTraceReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'graph': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'values': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputContractRejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_feedback': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputContractResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'interface_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'catalog_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'root': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'selector': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dialect': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'records': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputFeedback': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'issues': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'truncated': {'title': None, 'description': 'Additional diagnostic detail was omitted due to a work, item or byte bound.', 'has_default': False, 'default': None}, 'describe_input': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputIssue': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'instance_pointer': {'title': None, 'description': 'JSON Pointer to the invalid field; non-exact locations redact dynamic keys as * or use the root.', 'has_default': False, 'default': None}, 'location_exact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'keyword': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputSchemaRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'name': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_json': {'title': None, 'description': 'Exact JSON Schema definition serialized as a JSON document; $refs name other returned/selectable definitions. Not a standalone validator without its closure.', 'has_default': False, 'default': None}}}, 'InspectCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InspectNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InspectableHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'InspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'MaintainEvidenceCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expected_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'apply': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'MaintainEvidenceResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applied': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changed_files': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'removed_files': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ModuleRelationshipKey': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'MovePolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'after_policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NavigationIndexEntry': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'entrypoint': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'destinations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NavigationIndexesResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'indexes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NavigationRetarget': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'entrypoint': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NewPolicyUnit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'heading_chain': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'intent': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'aliases': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'predecessors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'NonEmptyString': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'NotExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expression': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'Obligation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reasons': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'permitted_submissions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'review_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ObligationId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'OperationalReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'canonical_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application_exposure': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'OutputContractRejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_feedback': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'OutputContractResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'interface_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'catalog_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'selector': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dialect': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'records': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'roots': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'root_schema_json': {'title': None, 'description': 'Exact operation result schema without $defs. Combine with all result-root definition pages for validation; schema_digest binds the full schema.', 'has_default': False, 'default': None}, 'schema_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'OutputSchemaRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'name': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_json': {'title': None, 'description': 'Exact JSON Schema definition serialized as a JSON document; $refs name other returned/selectable definitions. Not a standalone validator without its closure.', 'has_default': False, 'default': None}}}, 'PendingResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changed_units': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_requirements': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyCoverageStatus': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyImpactSelectionReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edge': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'traces': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'declaration': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'representation_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'structural_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyRelationship': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'source_policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer_scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyRelationshipInspection': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'relationship_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer_scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'propagation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyRelationshipKey': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyScopeUpdate': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'heading_path': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicySemanticIntent': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'PolicySummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyUnitDeclaration': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'module': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'heading_path': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'lifecycle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'aliases': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'predecessors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyUnitMapping': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reason': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_units': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PrepareCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PreservePolicySemantics': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'intent': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PreviewApplicationCall': {'title': None, 'description': 'Authoring-only inspection of an exact draft through application qualification and filtering; this observation neither publishes nor grants ordinary application access.', 'has_default': False, 'default': None, 'properties': {'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PreviewApplicationResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ProposalHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ProposalPolicySummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'related': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application_exposure': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalRelatedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authoring_target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_unit_mapping': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationships': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalRelationshipSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'traversal_eligible': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalRevisionHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalRevisionId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ProposalRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'proposal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'head_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposeCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ProvenanceReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'record': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProvenanceRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'path': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProvideFactSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProviderReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'contract_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PublicationCheckoutObservation': {'title': None, 'description': 'Fresh read-only observation of one selected checkout. Unavailable observations use null for every fact that could not be established.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'worktree_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'symbolic_branch': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'head': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'index_observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication_path_count': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'index_paths': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'worktree_paths': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PublicationPathCounts': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'predecessor': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'candidate': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'conflicted': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PublicationTargetObservation': {'title': None, 'description': 'Fresh bounded observation of the configured target ref; an unavailable revision is null.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PutDecisionProvenanceEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'record': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PutPolicyRelationshipEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PutRoutingFactEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PutRoutingRuleEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rule': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QuarantinedSnapshotSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'lifecycle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'created_at': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purge_deadline': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryProposalNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'QueryRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'QueryResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'Question': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prompt': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'permitted_answers': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_coverage': {'title': None, 'description': 'Include current repository attestation status for registered policy units in this read scope.', 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact preserves exact policy and essential authority; full includes all relationship rows.', 'has_default': False, 'default': None}}}, 'ReadCoverage': {'title': None, 'description': 'Repository attestation status bound to this snapshot or proposal. Empty subjects means no registered policy units in scope, not complete coverage. Analysis-local attestations are not repository certificates.', 'has_default': False, 'default': None, 'properties': {'subjects': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadManyCall': {'title': None, 'description': 'Read 1–32 selected items from one explicit snapshot, preserving order. The complete JSON result is limited to 2 MiB; any failed item rejects the entire request.', 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadManyItem': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_coverage': {'title': None, 'description': 'Include current repository attestation status for registered policy units in this read scope.', 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact preserves exact policy and essential authority; full includes all relationship rows.', 'has_default': False, 'default': None}}}, 'ReadManyResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_coverage': {'title': None, 'description': 'Include current repository attestation status for registered policy units in this read scope.', 'has_default': False, 'default': None}}}, 'ReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'related': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application_exposure': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadinessHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadinessId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ReadingPlanEntry': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reasons': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadingPlanReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RecoverApplicationCall': {'title': None, 'description': 'Recover an admitted application. Observation performs no Git writes. Explicit completion reconstructs and verifies the exact admitted candidate before one compare-and-swap attempt.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'action': {'title': None, 'description': 'Omit or select observe to reconcile only. Explicit complete-publication revalidates and attempts the same admitted candidate against its original expected target; it requires current publication authorization.', 'has_default': False, 'default': None}}}, 'RecoverApplicationResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checkout': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RecoverCall': {'title': None, 'description': 'Recover an admitted application. Observation performs no Git writes. Explicit completion reconstructs and verifies the exact admitted candidate before one compare-and-swap attempt.', 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'action': {'title': None, 'description': 'Omit or select observe to reconcile only. Explicit complete-publication revalidates and attempts the same admitted candidate against its original expected target; it requires current publication authorization.', 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'RegisterConsumerEdit': {'title': None, 'description': 'Register an existing tracked consumer within this proposal. The Engine captures original-revision bytes; use separate policy relationships to declare consumers and review obligations.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'path': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'artifact_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RegisterPolicyUnitEdit': {'title': None, 'description': 'Register an explicitly selected policy scope in an existing standard. The Engine owns declaration placement and validates the final candidate.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_unit': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'details': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_feedback': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_groups': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelatedCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'transitive': {'title': None, 'description': None, 'has_default': True, 'default': False}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelatedRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'transitive': {'title': None, 'description': None, 'has_default': True, 'default': False}}}, 'RelatedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authoring_target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_unit_mapping': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationships': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelationshipConsumer': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RelationshipDisposition': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'disposition': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'replacement_consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelationshipGroup': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'description': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'traversal_directions': {'title': None, 'description': 'Directions permitted by this group for traversals; adjacency queries remain distinct.', 'has_default': False, 'default': None}, 'transitive': {'title': None, 'description': 'Whether the group permits transitive traversal.', 'has_default': False, 'default': None}}}, 'RelationshipGroupsCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': 'Continue with the exact snapshot and offset returned by next. Nonzero offsets require a snapshot.', 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': 'Whole records per page, default 8; byte pressure may return fewer.', 'has_default': False, 'default': None}}}, 'RelationshipGroupsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelationshipInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelationshipKey': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RelationshipSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'traversal_eligible': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RemovePolicyRelationshipEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RemoveRoutingFactEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RemoveRoutingRuleEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rule': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReplaceStandardRelationshipsEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RepositoryPath': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RequestEvidenceTable': {'title': None, 'description': 'At most 128 request-local named exact references. Every entry must be used; each evidence_ref must name an entry. Expanded native validation and all ordinary evidence checks still apply.', 'has_default': False, 'default': None, 'properties': {}}, 'RequiresReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edge': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ResolveCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submission': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ResolveManyCall': {'title': None, 'description': 'Resolve ordered decisions bound to one original analysis. Validate every item before publishing a final immutable successor; an invalid batch persists no intermediate decisions.', 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submissions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ResolveNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'work': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ResolveWorkflowCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submission': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ResumeCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'RetireDecisionProvenanceEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RetirePolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retired_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RetireStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviewCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decisions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ReviewDecision': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviewProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decisions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prior_readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviewProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviewScope': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ReviseCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ReviseOperationalArtifactEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'title': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'body': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RevisePolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'title': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'body': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviseProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expected_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviseProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviseStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope_updates': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RewriteNavigationIndexEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'entrypoint': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'destinations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retargets': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RouteCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact authoring selection is default. Full returns the rule explanation. Application always retains its qualified projection.', 'has_default': False, 'default': None}}}, 'RouteContentSelection': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'offset': {'title': None, 'description': 'Default zero. A nonzero offset requires an explicit snapshot from the same route.', 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': 'Maximum whole policy reads in this page; default eight. Byte pressure may return fewer.', 'has_default': False, 'default': None}}}, 'RouteRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutedContentPage': {'title': None, 'description': 'Exact compact reads of selected targets in Router order. Total counts selected targets, not unresolved applicability. Follow next unchanged for the remaining page.', 'has_default': False, 'default': None, 'properties': {'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingBaseReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'projection': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingConfiguration': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rules': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingFactAssertion': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RoutingFactAssertions': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RoutingFactsCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingFactsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingQuestion': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prompt': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingRuleExplanation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingRuleReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rule': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RuntimeInfoCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'expected_catalog': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RuntimeInfoResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'interface_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'implementation_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'instance_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'implementation_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'catalog_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'installation_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'client_catalog_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'action': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ScalarValue': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'SelectionReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'SemanticProposal': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'intent': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'structural_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'SnapshotChildHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'child_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'child_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'SnapshotHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'SnapshotId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'SnapshotInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'SnapshotSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'SpecializesReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edge': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'StandardContent': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'title': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'level': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applies_when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'does_not_apply_when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'body': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'StandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'StandardsChangePurpose': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'StandardsChangeSet': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edits': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'StructuredScope': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'heading_path': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'Submission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'Timestamp': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'UndeleteSnapshotCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'UndeleteSnapshotResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerificationFailure': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'suite': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'check': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerificationReport': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'passed': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'exit_code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'suites': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checks': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'failures': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerifyProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerifyProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerifyRepositoryCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'refresh_verification_inputs': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerifyRepositoryResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'refreshed_verification_inputs': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WholeArtifactScope': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WithdrawApplicationContentEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowAnalysisSummary': {'title': None, 'description': 'Counts for the enclosing immutable Analysis context. Observation remains summary-only; successful compact pending mutations additionally return a bounded work page.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'required_obligations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'pending_facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'sections': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'details': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowContext': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'WorkflowContinuation': {'title': None, 'description': 'Select the named operation with the enclosing WorkflowResult context and explicit required inputs. This descriptor is not an authorization grant.', 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'required_inputs': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowDetailItem': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'WorkflowDetailsCall': {'title': None, 'description': 'Read a section of an immutable historical Analysis. Compact pages (default eight items) contain up to 16 whole records and 64 KiB of result JSON, returning fewer items when needed. An oversized record returns an explicit full-detail retry. detail=full retrieves one complete record (limit omitted or 1) without the compact byte cap; choose it only when the client can receive that payload. Continuations bind the Analysis, section and projected contents. Decision and publication operations check current evidence and authorization. A full-record response resumes compact paging in its next request.', 'has_default': False, 'default': None, 'properties': {'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact is byte-bounded; full explicitly retrieves one whole record without the compact byte cap.', 'has_default': False, 'default': None}}}, 'WorkflowDetailsLink': {'title': None, 'description': 'Supply the enclosing WorkflowResult Analysis context as analysis and explicitly select a section.', 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowDetailsNextOperation': {'title': None, 'description': 'An explicit historical detail retrieval alternative. Invoke operation with request; do not automatically select size-unbounded full detail.', 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowDetailsResult': {'title': None, 'description': 'Whole records from an immutable Analysis section. Compact may return fewer than limit to respect 64 KiB. Full returns at most one complete record and may exceed 64 KiB. Follow next exactly; observation and total are independent of page size and detail mode.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowDetailsSelection': {'title': None, 'description': 'A workflow_details selection relative to the enclosing WorkflowResult Analysis context. Add analysis from that context when invoking; preserve every returned selection field.', 'has_default': False, 'default': None, 'properties': {'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact is byte-bounded; full explicitly retrieves one whole record without the compact byte cap.', 'has_default': False, 'default': None}}}, 'WorkflowObligationWork': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'work': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowOutcome': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'WorkflowResult': {'title': None, 'description': 'Exact immutable workflow context and relative action descriptors. Successful compact pending propose, revise, analyze and decision submissions include work from the already-produced Analysis. Status observations, full results, stale contexts and other outcomes omit work.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checkout': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'work': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowSection': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'WorkflowSectionCount': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'count': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowStatusCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'WorkflowWorkDeferred': {'title': None, 'description': 'The mutation succeeded but its first complete work record exceeds the compact page budget. Preserve the enclosing context and counts; request explicitly selects that exact full record without the compact byte cap.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowWorkPage': {'title': None, 'description': 'First actionable section of a successful compact pending mutation, bound to the enclosing Analysis context. Facts precede obligations. Up to eight whole items and 64 KiB of page JSON; next is a relative workflow_details selection. Work handles retain their complete authority.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}}) +_SCHEMA = json.loads('{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://coding-standards.local/contracts/standards-engine/a2-v40","title":"Standards Engine A2 contract","description":"Canonical typed contract for snapshot lifecycle, controlled authoring, navigation, inspection, and immutable standards-change analysis.","oneOf":[{"$ref":"#/$defs/AgentProposeCall"},{"$ref":"#/$defs/AgentResolveManyCall"},{"$ref":"#/$defs/AgentResolveWorkflowCall"},{"$ref":"#/$defs/AgentReviewCall"},{"$ref":"#/$defs/AgentReviseCall"},{"$ref":"#/$defs/AgentRouteResult"},{"$ref":"#/$defs/AnalyzeCall"},{"$ref":"#/$defs/AnalyzeProposalCall"},{"$ref":"#/$defs/ApplicationInspectCall"},{"$ref":"#/$defs/ApplicationQueryCall"},{"$ref":"#/$defs/ApplicationReadCall"},{"$ref":"#/$defs/ApplicationReadManyCall"},{"$ref":"#/$defs/ApplicationReadManyResult"},{"$ref":"#/$defs/ApplicationReadResult"},{"$ref":"#/$defs/ApplicationRecoveryRequiredResult"},{"$ref":"#/$defs/ApplicationRejectedResult"},{"$ref":"#/$defs/ApplicationRelatedResult"},{"$ref":"#/$defs/ApplicationRouteResult"},{"$ref":"#/$defs/ApplicationRoutingFactsResult"},{"$ref":"#/$defs/ApplyCall"},{"$ref":"#/$defs/ApplyProposalCall"},{"$ref":"#/$defs/ApplyProposalResult"},{"$ref":"#/$defs/CompactReadResult"},{"$ref":"#/$defs/CompactRouteResult"},{"$ref":"#/$defs/CompleteResult"},{"$ref":"#/$defs/CreateProposalCall"},{"$ref":"#/$defs/CreateProposalResult"},{"$ref":"#/$defs/CreateSnapshotCall"},{"$ref":"#/$defs/CreateSnapshotResult"},{"$ref":"#/$defs/DeleteSnapshotCall"},{"$ref":"#/$defs/DeleteSnapshotResult"},{"$ref":"#/$defs/DescribeInputCall"},{"$ref":"#/$defs/DescribeOutputCall"},{"$ref":"#/$defs/FindProposalsCall"},{"$ref":"#/$defs/FindProposalsResult"},{"$ref":"#/$defs/FindSnapshotsCall"},{"$ref":"#/$defs/FindSnapshotsResult"},{"$ref":"#/$defs/InputContractRejectedResult"},{"$ref":"#/$defs/InputContractResult"},{"$ref":"#/$defs/InspectCall"},{"$ref":"#/$defs/InspectionResult"},{"$ref":"#/$defs/MaintainEvidenceCall"},{"$ref":"#/$defs/MaintainEvidenceResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/OperationalReadResult"},{"$ref":"#/$defs/OutputContractRejectedResult"},{"$ref":"#/$defs/OutputContractResult"},{"$ref":"#/$defs/PendingResult"},{"$ref":"#/$defs/PrepareCall"},{"$ref":"#/$defs/PreviewApplicationCall"},{"$ref":"#/$defs/PreviewApplicationResult"},{"$ref":"#/$defs/ProposeCall"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/QueryCall"},{"$ref":"#/$defs/QueryProposalCall"},{"$ref":"#/$defs/QueryProposalResult"},{"$ref":"#/$defs/QueryResult"},{"$ref":"#/$defs/ReadCall"},{"$ref":"#/$defs/ReadManyCall"},{"$ref":"#/$defs/ReadManyResult"},{"$ref":"#/$defs/ReadResult"},{"$ref":"#/$defs/RecoverApplicationCall"},{"$ref":"#/$defs/RecoverApplicationResult"},{"$ref":"#/$defs/RecoverCall"},{"$ref":"#/$defs/RejectedResult"},{"$ref":"#/$defs/RelatedCall"},{"$ref":"#/$defs/RelatedResult"},{"$ref":"#/$defs/RelationshipGroupsCall"},{"$ref":"#/$defs/RelationshipGroupsResult"},{"$ref":"#/$defs/ResolveCall"},{"$ref":"#/$defs/ResolveManyCall"},{"$ref":"#/$defs/ResolveWorkflowCall"},{"$ref":"#/$defs/ResumeCall"},{"$ref":"#/$defs/ReviewCall"},{"$ref":"#/$defs/ReviewProposalCall"},{"$ref":"#/$defs/ReviewProposalResult"},{"$ref":"#/$defs/ReviseCall"},{"$ref":"#/$defs/ReviseProposalCall"},{"$ref":"#/$defs/ReviseProposalResult"},{"$ref":"#/$defs/RouteCall"},{"$ref":"#/$defs/RoutingFactsCall"},{"$ref":"#/$defs/RoutingFactsResult"},{"$ref":"#/$defs/RuntimeInfoCall"},{"$ref":"#/$defs/RuntimeInfoResult"},{"$ref":"#/$defs/UndeleteSnapshotCall"},{"$ref":"#/$defs/UndeleteSnapshotResult"},{"$ref":"#/$defs/VerifyProposalCall"},{"$ref":"#/$defs/VerifyProposalResult"},{"$ref":"#/$defs/VerifyRepositoryCall"},{"$ref":"#/$defs/VerifyRepositoryResult"},{"$ref":"#/$defs/WorkflowDetailsCall"},{"$ref":"#/$defs/WorkflowDetailsResult"},{"$ref":"#/$defs/WorkflowResult"},{"$ref":"#/$defs/WorkflowStatusCall"}],"$defs":{"NonEmptyString":{"type":"string","minLength":1},"CanonicalId":{"type":"string","pattern":"^[A-Za-z0-9][A-Za-z0-9._:/-]*$"},"EdgeId":{"type":"string","minLength":1},"Digest":{"type":"string","pattern":"^sha256:[0-9a-f]{64}$","maxLength":71},"GitObjectId":{"oneOf":[{"type":"string","pattern":"^[0-9a-f]{40}$"},{"type":"string","pattern":"^[0-9a-f]{64}$"}]},"ObligationId":{"type":"string","pattern":"^obligation:sha256:[0-9a-f]{64}$"},"ImpactTraceId":{"type":"string","pattern":"^impact-trace:sha256:[0-9a-f]{64}$"},"FactRequirementId":{"type":"string","pattern":"^fact-requirement:sha256:[0-9a-f]{64}$"},"ScalarValue":{"oneOf":[{"type":"boolean"},{"type":"integer"},{"type":"string"},{"type":"null"}]},"FactValue":{"oneOf":[{"type":"object","required":["type","state","value"],"properties":{"type":{"const":"boolean"},"state":{"const":"known"},"value":{"type":"boolean"}},"additionalProperties":false},{"type":"object","required":["type","state","value"],"properties":{"type":{"enum":["boolean","enum","string","string-set","enum-set","canonical-id"]},"state":{"const":"known"},"value":{"type":"null"}},"additionalProperties":false},{"type":"object","required":["type","state","value"],"properties":{"type":{"enum":["enum","string","canonical-id"]},"state":{"const":"known"},"value":{"type":"string"}},"additionalProperties":false},{"type":"object","required":["type","state","value"],"properties":{"type":{"enum":["string-set","enum-set"]},"state":{"const":"known"},"value":{"type":"array","items":{"type":"string"},"uniqueItems":true}},"additionalProperties":false},{"type":"object","required":["type","state"],"properties":{"type":{"enum":["boolean","enum","string","string-set","enum-set","canonical-id"]},"state":{"enum":["known-absent","unknown"]}},"additionalProperties":false}]},"FactSet":{"type":"object","additionalProperties":{"$ref":"#/$defs/FactValue"}},"StructuredScope":{"type":"object","required":["kind","heading_path"],"properties":{"kind":{"const":"structured"},"heading_path":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/NonEmptyString"}}},"additionalProperties":false},"WholeArtifactScope":{"type":"object","required":["kind"],"properties":{"kind":{"const":"whole-artifact"}},"additionalProperties":false},"ReviewScope":{"oneOf":[{"$ref":"#/$defs/StructuredScope"},{"$ref":"#/$defs/WholeArtifactScope"}]},"AllExpression":{"type":"object","required":["operator","expressions"],"properties":{"operator":{"const":"all"},"expressions":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/ApplicabilityExpression"}}},"additionalProperties":false},"AnyExpression":{"type":"object","required":["operator","expressions"],"properties":{"operator":{"const":"any"},"expressions":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/ApplicabilityExpression"}}},"additionalProperties":false},"NotExpression":{"type":"object","required":["operator","expression"],"properties":{"operator":{"const":"not"},"expression":{"$ref":"#/$defs/ApplicabilityExpression"}},"additionalProperties":false},"EqualsExpression":{"type":"object","required":["operator","fact","value"],"properties":{"operator":{"const":"equals"},"fact":{"$ref":"#/$defs/CanonicalId"},"value":{"$ref":"#/$defs/ScalarValue"}},"additionalProperties":false},"InExpression":{"type":"object","required":["operator","fact","values"],"properties":{"operator":{"const":"in"},"fact":{"$ref":"#/$defs/CanonicalId"},"values":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/ScalarValue"}}},"additionalProperties":false},"ContainsExpression":{"type":"object","required":["operator","fact","value"],"properties":{"operator":{"const":"contains"},"fact":{"$ref":"#/$defs/CanonicalId"},"value":{"$ref":"#/$defs/ScalarValue"}},"additionalProperties":false},"ExistsExpression":{"type":"object","required":["operator","fact"],"properties":{"operator":{"const":"exists"},"fact":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"AlwaysExpression":{"type":"object","required":["operator"],"properties":{"operator":{"const":"always"}},"additionalProperties":false},"ApplicabilityExpression":{"oneOf":[{"$ref":"#/$defs/AlwaysExpression"},{"$ref":"#/$defs/AllExpression"},{"$ref":"#/$defs/AnyExpression"},{"$ref":"#/$defs/NotExpression"},{"$ref":"#/$defs/EqualsExpression"},{"$ref":"#/$defs/InExpression"},{"$ref":"#/$defs/ContainsExpression"},{"$ref":"#/$defs/ExistsExpression"}]},"GeneralSelectionReason":{"type":"object","required":["kind"],"properties":{"kind":{"enum":["routing-fact","requires","specializes","changed-policy","question","audit-coverage","unmapped-normative-change","structured-scope-analysis-unsupported","navigation-index-change","supporting-content-change"]},"source":{"$ref":"#/$defs/CanonicalId"},"fact":{"$ref":"#/$defs/CanonicalId"},"edge":{"$ref":"#/$defs/EdgeId"},"question":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"PolicyImpactSelectionReason":{"type":"object","required":["kind","source","edge","relation","evidence_owner","traces"],"properties":{"kind":{"const":"policy-impact-edge"},"source":{"$ref":"#/$defs/CanonicalId"},"edge":{"$ref":"#/$defs/EdgeId"},"relation":{"$ref":"#/$defs/CanonicalId"},"evidence_owner":{"$ref":"#/$defs/CanonicalId"},"traces":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/ImpactTraceReference"}}},"additionalProperties":false},"SelectionReason":{"oneOf":[{"$ref":"#/$defs/GeneralSelectionReason"},{"$ref":"#/$defs/PolicyImpactSelectionReason"}]},"ImpactTraceReference":{"type":"object","required":["id","graph","applicability"],"properties":{"id":{"$ref":"#/$defs/ImpactTraceId"},"graph":{"enum":["accepted","proposed"]},"applicability":{"enum":["true","false","unknown"]}},"additionalProperties":false},"ConsumerReviewObligationReadingReason":{"type":"object","required":["kind","obligation"],"properties":{"kind":{"const":"consumer-review-obligation"},"obligation":{"$ref":"#/$defs/ObligationId"}},"additionalProperties":false},"RoutingBaseReadingReason":{"type":"object","required":["kind","projection"],"properties":{"kind":{"const":"routing-base"},"projection":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"RoutingRuleReadingReason":{"type":"object","required":["kind","rule","facts"],"properties":{"kind":{"const":"routing-rule"},"rule":{"$ref":"#/$defs/CanonicalId"},"facts":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"RequiresReadingReason":{"type":"object","required":["kind","edge","source"],"properties":{"kind":{"const":"requires"},"edge":{"$ref":"#/$defs/EdgeId"},"source":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"SpecializesReadingReason":{"type":"object","required":["kind","edge","source"],"properties":{"kind":{"const":"specializes"},"edge":{"$ref":"#/$defs/EdgeId"},"source":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"ReadingPlanReason":{"oneOf":[{"$ref":"#/$defs/ConsumerReviewObligationReadingReason"},{"$ref":"#/$defs/RoutingBaseReadingReason"},{"$ref":"#/$defs/RoutingRuleReadingReason"},{"$ref":"#/$defs/RequiresReadingReason"},{"$ref":"#/$defs/SpecializesReadingReason"}]},"ReadingPlanEntry":{"type":"object","required":["target","scope","authority","reasons","state"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"scope":{"$ref":"#/$defs/ReviewScope"},"authority":{"enum":["normative","projection","contextual","evidence"]},"reasons":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/ReadingPlanReason"}},"state":{"enum":["selected","conditional","unresolved"]}},"additionalProperties":false},"RouteRequest":{"type":"object","required":["kind","facts"],"properties":{"kind":{"const":"route"},"facts":{"$ref":"#/$defs/FactSet"}},"additionalProperties":false},"ReadRequest":{"type":"object","required":["kind","target"],"properties":{"kind":{"const":"read"},"target":{"$ref":"#/$defs/CanonicalId"},"include_routing":{"type":"boolean"},"include_coverage":{"type":"boolean","description":"Include current repository attestation status for registered policy units in this read scope."}},"additionalProperties":false},"RelatedRequest":{"type":"object","required":["kind","target","groups","direction","transitive"],"properties":{"kind":{"const":"related"},"target":{"$ref":"#/$defs/CanonicalId"},"groups":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"direction":{"enum":["incoming","outgoing","both"]},"transitive":{"type":"boolean","default":false}},"additionalProperties":false},"QueryRequest":{"oneOf":[{"$ref":"#/$defs/RouteRequest"},{"$ref":"#/$defs/ReadRequest"},{"$ref":"#/$defs/RelatedRequest"}]},"PolicyUnitDeclaration":{"type":"object","required":["kind","id","module","heading_path","semantic_revision","lifecycle"],"properties":{"kind":{"const":"policy-unit"},"id":{"$ref":"#/$defs/CanonicalId"},"module":{"$ref":"#/$defs/CanonicalId"},"heading_path":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/NonEmptyString"}},"semantic_revision":{"type":"integer","minimum":1},"lifecycle":{"const":"active"},"aliases":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"predecessors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"CanonicalModuleDeclaration":{"type":"object","required":["kind","id","role","level","applies_when","does_not_apply_when","requires","specializes","verification"],"properties":{"kind":{"const":"canonical-module"},"id":{"$ref":"#/$defs/CanonicalId"},"role":{"enum":["core","router","workflow","profile","topic","reference"]},"level":{"enum":["MUST","SHOULD","PROFILE","REFERENCE"]},"applies_when":{"$ref":"#/$defs/NonEmptyString"},"does_not_apply_when":{"$ref":"#/$defs/NonEmptyString"},"requires":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"verification":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PolicyRelationshipInspection":{"type":"object","required":["relationship_kind","applicability","source_scope","consumer_scope","propagation","evidence_owner","rationale"],"properties":{"relationship_kind":{"enum":["normative-consumer","router-projection","prompt-projection","template-projection","reference-projection","fixture-projection","enforcement-suite-projection","documentation-projection","implementation-projection"]},"applicability":{"$ref":"#/$defs/ApplicabilityExpression"},"source_scope":{"oneOf":[{"$ref":"#/$defs/ReviewScope"},{"type":"null"}]},"consumer_scope":{"oneOf":[{"$ref":"#/$defs/ReviewScope"},{"type":"null"}]},"propagation":{"const":"source-to-consumer"},"evidence_owner":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"SemanticProposal":{"type":"object","required":["policy","accepted_semantic_revision","proposed_semantic_revision","intent","structural_digest"],"properties":{"policy":{"$ref":"#/$defs/CanonicalId"},"accepted_semantic_revision":{"oneOf":[{"type":"integer","minimum":1},{"type":"null"}]},"proposed_semantic_revision":{"type":"integer","minimum":1},"intent":{"$ref":"#/$defs/NonEmptyString"},"structural_digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"ChangeDescriptor":{"type":"object","required":["kind","accepted_ids","proposed_ids","scope"],"properties":{"kind":{"enum":["module","modification","addition","removal","move","split","merge","navigation-index","supporting-content"]},"accepted_ids":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"proposed_ids":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"scope":{"$ref":"#/$defs/ReviewScope"},"accepted_module":{"$ref":"#/$defs/CanonicalId"},"proposed_module":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"ChangedPolicyUnit":{"type":"object","required":["policy","change_kind","classification","accepted_representation_digest","proposed_representation_digest","accepted_structural_digest","proposed_structural_digest","accepted_semantic_revision","proposed_semantic_revision","semantic_state","scope"],"properties":{"policy":{"$ref":"#/$defs/CanonicalId"},"change_kind":{"enum":["modification","addition","removal","move","split-predecessor","split-successor","merge-predecessor","merge-successor"]},"classification":{"enum":["unchanged","representation-only-candidate","possibly-semantically-changed","semantically-changed","unresolved"]},"accepted_representation_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"proposed_representation_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"accepted_structural_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"proposed_structural_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"accepted_semantic_revision":{"oneOf":[{"type":"integer","minimum":1},{"type":"null"}]},"proposed_semantic_revision":{"oneOf":[{"type":"integer","minimum":1},{"type":"null"}]},"semantic_state":{"enum":["accepted-unchanged","proposed","removed","unresolved"]},"scope":{"$ref":"#/$defs/ReviewScope"}},"additionalProperties":false},"Question":{"type":"object","required":["id","kind","prompt","state","permitted_answers"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"kind":{"enum":["applicability-fact","normative-classification","identity-resolution","scope-resolution"]},"prompt":{"$ref":"#/$defs/NonEmptyString"},"state":{"enum":["required","answered","blocked"]},"permitted_answers":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/NonEmptyString"}}},"additionalProperties":false},"ConsumerReviewContract":{"type":"object","required":["kind","id","version","permitted_dispositions","evidence_contract","authorization_capability","semantics"],"properties":{"kind":{"const":"consumer-review-contract"},"id":{"$ref":"#/$defs/CanonicalId"},"version":{"type":"integer","minimum":1},"permitted_dispositions":{"type":"array","minItems":1,"uniqueItems":true,"items":{"enum":["updated","reviewed-no-change","not-applicable","blocked"]}},"evidence_contract":{"$ref":"#/$defs/CanonicalId"},"authorization_capability":{"$ref":"#/$defs/CanonicalId"},"semantics":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"DecisionDependency":{"type":"object","required":["class","identity","digest"],"properties":{"class":{"enum":["policy-unit","semantic-revision","structure","representation","module-locator","applicability-fact","relationship","audit","exception","evidence","provider-contract","applicability-contract","analysis-contract"]},"identity":{"$ref":"#/$defs/NonEmptyString"},"digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"DecisionFingerprint":{"type":"object","required":["decision_kind","decision_contract","schema_version","dependencies"],"properties":{"decision_kind":{"$ref":"#/$defs/CanonicalId"},"decision_contract":{"$ref":"#/$defs/CanonicalId"},"schema_version":{"const":1},"dependencies":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/DecisionDependency"}}},"additionalProperties":false},"FactValueContract":{"type":"object","required":["type","states","nullable"],"properties":{"type":{"enum":["boolean","enum","string","string-set","enum-set","canonical-id"]},"states":{"const":["known","known-absent"]},"nullable":{"type":"boolean"},"values":{"type":"array","minItems":1,"uniqueItems":true,"items":{"type":"string"}}},"additionalProperties":false},"EvidenceReference":{"type":"object","required":["id","digest","provider_contract","provider_contract_version"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"digest":{"$ref":"#/$defs/Digest"},"provider_contract":{"$ref":"#/$defs/CanonicalId"},"provider_contract_version":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"CompletionProof":{"type":"object","required":["required_coverage_subjects","certificate_subjects","reached_consumer_obligations","disposition_obligations","required_fact_requirements","observed_fact_requirements","non_consumer_obligations_resolved","applicability_resolved","authorization_valid","evidence_valid"],"properties":{"required_coverage_subjects":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"certificate_subjects":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"reached_consumer_obligations":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/ObligationId"}},"disposition_obligations":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/ObligationId"}},"required_fact_requirements":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/FactRequirementId"}},"observed_fact_requirements":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/FactRequirementId"}},"non_consumer_obligations_resolved":{"const":true},"applicability_resolved":{"const":true},"authorization_valid":{"const":true},"evidence_valid":{"const":true}},"additionalProperties":false},"Timestamp":{"type":"integer","minimum":0},"SnapshotId":{"type":"string","pattern":"^snapshot:v1:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"},"AnalysisId":{"type":"string","pattern":"^analysis:sha256:[0-9a-f]{64}$"},"ProposalId":{"type":"string","pattern":"^proposal:v1:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"},"ProposalRevisionId":{"type":"string","pattern":"^proposal-revision:sha256:[0-9a-f]{64}$"},"ReadinessId":{"type":"string","pattern":"^readiness:sha256:[0-9a-f]{64}$"},"ApplicationId":{"type":"string","pattern":"^application:sha256:[0-9a-f]{64}$"},"ChildId":{"type":"string","pattern":"^sha256:[0-9a-f]{64}$"},"AuthorizationId":{"type":"string","pattern":"^authorization:sha256:[0-9a-f]{64}$"},"SnapshotHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"snapshot-handle"},"id":{"$ref":"#/$defs/SnapshotId"},"schema_version":{"const":5}},"additionalProperties":false},"AnalysisHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"analysis-handle"},"id":{"$ref":"#/$defs/AnalysisId"},"schema_version":{"const":7}},"additionalProperties":false},"ProposalHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"proposal-handle"},"id":{"$ref":"#/$defs/ProposalId"},"schema_version":{"const":1}},"additionalProperties":false},"ProposalRevisionHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"proposal-revision-handle"},"id":{"$ref":"#/$defs/ProposalRevisionId"},"schema_version":{"const":1}},"additionalProperties":false},"ReadinessHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"readiness-handle"},"id":{"$ref":"#/$defs/ReadinessId"},"schema_version":{"const":1}},"additionalProperties":false},"ApplicationHandle":{"type":"object","required":["kind","id","schema_version"],"properties":{"kind":{"const":"application-handle"},"id":{"$ref":"#/$defs/ApplicationId"},"schema_version":{"const":1}},"additionalProperties":false},"SnapshotChildHandle":{"type":"object","required":["kind","snapshot","child_kind","child_id","schema_version"],"properties":{"kind":{"const":"snapshot-child-handle"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"child_kind":{"enum":["policy","relationship"]},"child_id":{"$ref":"#/$defs/NonEmptyString"},"schema_version":{"const":5}},"additionalProperties":false},"AnalysisChildHandle":{"type":"object","required":["kind","analysis","child_kind","child_id","schema_version"],"properties":{"kind":{"const":"analysis-child-handle"},"analysis":{"$ref":"#/$defs/AnalysisHandle"},"child_kind":{"enum":["context","fact-requirement","fact-observation","obligation","coverage-requirement","coverage-certificate"]},"child_id":{"$ref":"#/$defs/ChildId"},"schema_version":{"const":7}},"additionalProperties":false},"AnalysisMaterialHandle":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/ProposalRevisionHandle"}]},"InspectableHandle":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/AnalysisHandle"},{"$ref":"#/$defs/SnapshotChildHandle"},{"$ref":"#/$defs/AnalysisChildHandle"}]},"ActiveSnapshotSummary":{"type":"object","required":["snapshot","lifecycle","source_revision","created_at"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"lifecycle":{"const":"active"},"source_revision":{"$ref":"#/$defs/NonEmptyString"},"created_at":{"$ref":"#/$defs/Timestamp"}},"additionalProperties":false},"QuarantinedSnapshotSummary":{"type":"object","required":["snapshot","lifecycle","source_revision","created_at","purge_deadline"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"lifecycle":{"const":"quarantined"},"source_revision":{"$ref":"#/$defs/NonEmptyString"},"created_at":{"$ref":"#/$defs/Timestamp"},"purge_deadline":{"$ref":"#/$defs/Timestamp"}},"additionalProperties":false},"SnapshotSummary":{"oneOf":[{"$ref":"#/$defs/ActiveSnapshotSummary"},{"$ref":"#/$defs/QuarantinedSnapshotSummary"}]},"CreateSnapshotCall":{"type":"object","required":["kind"],"properties":{"kind":{"const":"create-snapshot"}},"additionalProperties":false},"CreateSnapshotResult":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"create-snapshot-result"},"snapshot":{"$ref":"#/$defs/ActiveSnapshotSummary"}},"additionalProperties":false},"FindSnapshotsCall":{"type":"object","required":["kind"],"properties":{"kind":{"const":"find-snapshots"},"lifecycle":{"enum":["active","quarantined"],"default":"active"},"after":{"$ref":"#/$defs/SnapshotHandle"},"limit":{"type":"integer","minimum":1,"default":50}},"additionalProperties":false},"FindSnapshotsResult":{"type":"object","required":["kind","snapshots"],"properties":{"kind":{"const":"find-snapshots-result"},"snapshots":{"type":"array","items":{"$ref":"#/$defs/SnapshotSummary"}},"continuation":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"StandardsChangePurpose":{"type":"object","required":["summary","rationale","evidence"],"properties":{"summary":{"$ref":"#/$defs/NonEmptyString"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"StandardContent":{"type":"object","required":["id","title","role","level","applies_when","does_not_apply_when","verification","body"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"title":{"$ref":"#/$defs/NonEmptyString"},"role":{"enum":["core","router","workflow","profile","topic","reference"]},"level":{"enum":["MUST","SHOULD","PROFILE","REFERENCE"]},"applies_when":{"$ref":"#/$defs/NonEmptyString"},"does_not_apply_when":{"$ref":"#/$defs/NonEmptyString"},"verification":{"$ref":"#/$defs/NonEmptyString"},"body":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"NewPolicyUnit":{"type":"object","required":["id","heading_chain","semantic_revision","intent","aliases","predecessors","successors"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"heading_chain":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/NonEmptyString"}},"semantic_revision":{"const":1},"intent":{"$ref":"#/$defs/NonEmptyString"},"aliases":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"predecessors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"PreservePolicySemantics":{"type":"object","required":["kind","semantic_revision","intent"],"properties":{"kind":{"const":"preserve"},"semantic_revision":{"type":"integer","minimum":1},"intent":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"ChangePolicySemantics":{"type":"object","required":["kind","accepted_semantic_revision","proposed_semantic_revision","intent"],"properties":{"kind":{"const":"change"},"accepted_semantic_revision":{"type":"integer","minimum":1},"proposed_semantic_revision":{"type":"integer","minimum":1},"intent":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PolicySemanticIntent":{"oneOf":[{"$ref":"#/$defs/PreservePolicySemantics"},{"$ref":"#/$defs/ChangePolicySemantics"}]},"CreateStandardEdit":{"type":"object","required":["kind","standard","requires","specializes","policy_units"],"properties":{"kind":{"const":"create-standard"},"standard":{"$ref":"#/$defs/StandardContent"},"requires":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"policy_units":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/NewPolicyUnit"}}},"additionalProperties":false},"RegisterPolicyUnitEdit":{"type":"object","description":"Register an explicitly selected policy scope in an existing standard. The Engine owns declaration placement and validates the final candidate.","required":["kind","standard","policy_unit"],"properties":{"kind":{"const":"register-policy-unit"},"standard":{"$ref":"#/$defs/CanonicalId"},"policy_unit":{"$ref":"#/$defs/NewPolicyUnit"}},"additionalProperties":false},"ReviseStandardEdit":{"type":"object","required":["kind","standard"],"properties":{"kind":{"const":"revise-standard"},"standard":{"$ref":"#/$defs/StandardContent"},"scope_updates":{"type":"array","items":{"$ref":"#/$defs/PolicyScopeUpdate"}}},"additionalProperties":false},"RevisePolicyUnitEdit":{"type":"object","required":["kind","policy","title","body","semantics"],"properties":{"kind":{"const":"revise-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"title":{"$ref":"#/$defs/NonEmptyString"},"body":{"$ref":"#/$defs/NonEmptyString"},"semantics":{"$ref":"#/$defs/PolicySemanticIntent"}},"additionalProperties":false},"MovePolicyUnitEdit":{"type":"object","required":["kind","policy","standard","semantics"],"properties":{"kind":{"const":"move-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"standard":{"$ref":"#/$defs/CanonicalId"},"after_policy":{"$ref":"#/$defs/CanonicalId"},"semantics":{"$ref":"#/$defs/PolicySemanticIntent"}},"additionalProperties":false},"RetirePolicyUnitEdit":{"type":"object","required":["kind","policy","retired_semantic_revision","successors","relationship_dispositions","evidence"],"properties":{"kind":{"const":"retire-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"retired_semantic_revision":{"type":"integer","minimum":1},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"relationship_dispositions":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/RelationshipDisposition"}},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"RetireStandardEdit":{"type":"object","required":["kind","standard","successors","relationship_dispositions","evidence"],"properties":{"kind":{"const":"retire-standard"},"standard":{"$ref":"#/$defs/CanonicalId"},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"relationship_dispositions":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/RelationshipDisposition"}},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"ReplaceStandardRelationshipsEdit":{"type":"object","required":["kind","standard","requires","specializes","rationale"],"properties":{"kind":{"const":"replace-standard-relationships"},"standard":{"$ref":"#/$defs/CanonicalId"},"requires":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"AuthoringTargetHandle":{"type":"object","required":["kind","snapshot","id","schema_version"],"properties":{"kind":{"const":"authoring-target-handle"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"id":{"$ref":"#/$defs/ChildId"},"schema_version":{"const":5}},"additionalProperties":false},"RelationshipConsumer":{"oneOf":[{"$ref":"#/$defs/CanonicalId"},{"$ref":"#/$defs/AuthoringTargetHandle"}]},"PolicyRelationship":{"type":"object","required":["source_policy","consumer","relation","applicability","source_scope","consumer_scope","evidence_owner","rationale"],"properties":{"source_policy":{"$ref":"#/$defs/CanonicalId"},"consumer":{"$ref":"#/$defs/RelationshipConsumer"},"relation":{"enum":["normative-consumer","router-projection","prompt-projection","template-projection","reference-projection","fixture-projection","enforcement-suite-projection","documentation-projection","implementation-projection"]},"applicability":{"$ref":"#/$defs/ApplicabilityExpression"},"source_scope":{"oneOf":[{"$ref":"#/$defs/ReviewScope"},{"type":"null"}]},"consumer_scope":{"oneOf":[{"$ref":"#/$defs/ReviewScope"},{"type":"null"}]},"evidence_owner":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PutPolicyRelationshipEdit":{"type":"object","required":["kind","relationship"],"properties":{"kind":{"const":"put-policy-relationship"},"relationship":{"$ref":"#/$defs/PolicyRelationship"}},"additionalProperties":false},"RemovePolicyRelationshipEdit":{"type":"object","required":["kind","relationship"],"properties":{"kind":{"const":"remove-policy-relationship"},"relationship":{"$ref":"#/$defs/PolicyRelationship"}},"additionalProperties":false},"ModuleRelationshipKey":{"type":"object","required":["kind","relation","source","target"],"properties":{"kind":{"const":"module-relationship"},"relation":{"enum":["requires","specializes"]},"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"PolicyRelationshipKey":{"type":"object","required":["kind","source_policy","consumer","relation"],"properties":{"kind":{"const":"policy-relationship"},"source_policy":{"$ref":"#/$defs/CanonicalId"},"consumer":{"$ref":"#/$defs/RelationshipConsumer"},"relation":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"RelationshipKey":{"oneOf":[{"$ref":"#/$defs/ModuleRelationshipKey"},{"$ref":"#/$defs/PolicyRelationshipKey"}]},"RelationshipDisposition":{"type":"object","required":["relationship","disposition","rationale","evidence"],"properties":{"relationship":{"$ref":"#/$defs/RelationshipKey"},"disposition":{"enum":["remove","retarget"]},"replacement_consumer":{"$ref":"#/$defs/RelationshipConsumer"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"StandardEdit":{"oneOf":[{"$ref":"#/$defs/CreateStandardEdit"},{"$ref":"#/$defs/RegisterPolicyUnitEdit"},{"$ref":"#/$defs/ReviseStandardEdit"},{"$ref":"#/$defs/RevisePolicyUnitEdit"},{"$ref":"#/$defs/MovePolicyUnitEdit"},{"$ref":"#/$defs/RetirePolicyUnitEdit"},{"$ref":"#/$defs/RetireStandardEdit"},{"$ref":"#/$defs/ReplaceStandardRelationshipsEdit"},{"$ref":"#/$defs/PutPolicyRelationshipEdit"},{"$ref":"#/$defs/RemovePolicyRelationshipEdit"},{"$ref":"#/$defs/PutRoutingRuleEdit"},{"$ref":"#/$defs/RemoveRoutingRuleEdit"},{"$ref":"#/$defs/PutRoutingFactEdit"},{"$ref":"#/$defs/RemoveRoutingFactEdit"},{"$ref":"#/$defs/AuditPolicyUnitEdit"},{"$ref":"#/$defs/RewriteNavigationIndexEdit"},{"$ref":"#/$defs/PutDecisionProvenanceEdit"},{"$ref":"#/$defs/RetireDecisionProvenanceEdit"},{"$ref":"#/$defs/ApproveApplicationContentEdit"},{"$ref":"#/$defs/WithdrawApplicationContentEdit"},{"$ref":"#/$defs/ReviseOperationalArtifactEdit"},{"$ref":"#/$defs/RegisterConsumerEdit"}]},"StandardsChangeSet":{"type":"object","required":["purpose","edits"],"properties":{"purpose":{"$ref":"#/$defs/StandardsChangePurpose"},"edits":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/StandardEdit"}}},"additionalProperties":false},"ProposalSummary":{"type":"object","required":["proposal","head_revision"],"properties":{"proposal":{"$ref":"#/$defs/ProposalHandle"},"head_revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"CreateProposalCall":{"type":"object","required":["kind","base_snapshot","change_set"],"properties":{"kind":{"const":"create-proposal"},"base_snapshot":{"$ref":"#/$defs/SnapshotHandle"},"change_set":{"$ref":"#/$defs/StandardsChangeSet"}},"additionalProperties":false},"CreateProposalResult":{"type":"object","required":["kind","proposal","revision"],"properties":{"kind":{"const":"create-proposal-result"},"proposal":{"$ref":"#/$defs/ProposalHandle"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"FindProposalsCall":{"type":"object","required":["kind"],"properties":{"kind":{"const":"find-proposals"},"after":{"$ref":"#/$defs/ProposalHandle"},"limit":{"type":"integer","minimum":1,"default":50}},"additionalProperties":false},"FindProposalsResult":{"type":"object","required":["kind","proposals"],"properties":{"kind":{"const":"find-proposals-result"},"proposals":{"type":"array","items":{"$ref":"#/$defs/ProposalSummary"}},"continuation":{"$ref":"#/$defs/ProposalHandle"}},"additionalProperties":false},"ReviseProposalCall":{"type":"object","required":["kind","expected_revision","change_set"],"properties":{"kind":{"const":"revise-proposal"},"expected_revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"change_set":{"$ref":"#/$defs/StandardsChangeSet"}},"additionalProperties":false},"ReviseProposalResult":{"type":"object","required":["kind","proposal","revision"],"properties":{"kind":{"const":"revise-proposal-result"},"proposal":{"$ref":"#/$defs/ProposalHandle"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"DeleteSnapshotCall":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"delete-snapshot"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"DeleteSnapshotResult":{"type":"object","required":["kind","snapshot","purge_deadline"],"properties":{"kind":{"const":"delete-snapshot-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"purge_deadline":{"$ref":"#/$defs/Timestamp"}},"additionalProperties":false},"UndeleteSnapshotCall":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"undelete-snapshot"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"UndeleteSnapshotResult":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"undelete-snapshot-result"},"snapshot":{"$ref":"#/$defs/ActiveSnapshotSummary"}},"additionalProperties":false},"QueryNextOperation":{"type":"object","required":["operation","request_kind","snapshot"],"properties":{"operation":{"const":"query"},"request_kind":{"enum":["route","read","related"]},"target":{"$ref":"#/$defs/CanonicalId"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"QueryProposalNextOperation":{"type":"object","required":["operation","request_kind","revision"],"properties":{"operation":{"const":"query_proposal"},"request_kind":{"enum":["route","read","related"]},"target":{"$ref":"#/$defs/CanonicalId"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"ResolveNextOperation":{"type":"object","required":["operation","request_kind","analysis"],"properties":{"operation":{"const":"resolve"},"request_kind":{"enum":["provide-fact","consumer-disposition","impact-disposition","coverage-attestation"]},"target":{"$ref":"#/$defs/CanonicalId"},"work":{"$ref":"#/$defs/AnalysisChildHandle"},"analysis":{"$ref":"#/$defs/AnalysisHandle"}},"additionalProperties":false},"InspectNextOperation":{"type":"object","required":["operation","request_kind","handle"],"properties":{"operation":{"const":"inspect"},"request_kind":{"const":"inspect"},"handle":{"$ref":"#/$defs/InspectableHandle"}},"additionalProperties":false},"NextOperation":{"oneOf":[{"$ref":"#/$defs/QueryNextOperation"},{"$ref":"#/$defs/ResolveNextOperation"},{"$ref":"#/$defs/InspectNextOperation"},{"$ref":"#/$defs/FocusedQueryNextOperation"},{"$ref":"#/$defs/WorkflowDetailsNextOperation"}]},"QueryCall":{"type":"object","required":["snapshot","request"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"request":{"$ref":"#/$defs/QueryRequest"}},"additionalProperties":false},"QueryProposalCall":{"type":"object","required":["revision","request"],"properties":{"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"request":{"$ref":"#/$defs/QueryRequest"}},"additionalProperties":false},"AnalyzeProposalCall":{"type":"object","required":["revision"],"properties":{"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}},"additionalProperties":false},"ReviewDecision":{"type":"object","required":["owner","decision","rationale","evidence"],"properties":{"owner":{"enum":["consumer","impact","audit"]},"decision":{"const":"accept"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/EvidenceReference"}}},"additionalProperties":false},"ReviewProposalCall":{"type":"object","required":["kind","analysis","decisions"],"properties":{"kind":{"const":"review-proposal"},"analysis":{"$ref":"#/$defs/AnalysisHandle"},"decisions":{"type":"array","minItems":3,"maxItems":3,"uniqueItems":true,"items":{"$ref":"#/$defs/ReviewDecision"}},"prior_readiness":{"$ref":"#/$defs/ReadinessHandle"}},"additionalProperties":false},"ReviewProposalResult":{"type":"object","required":["kind","readiness","revision","status"],"properties":{"kind":{"const":"review-proposal-result"},"readiness":{"$ref":"#/$defs/ReadinessHandle"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"status":{"const":"ready"}},"additionalProperties":false},"ApplyProposalCall":{"type":"object","required":["kind","readiness"],"properties":{"kind":{"const":"apply-proposal"},"readiness":{"$ref":"#/$defs/ReadinessHandle"}},"additionalProperties":false},"ApplyProposalResult":{"type":"object","required":["kind","application","status","publication","checkout"],"properties":{"kind":{"const":"apply-proposal-result"},"application":{"$ref":"#/$defs/ApplicationHandle"},"status":{"const":"applied"},"publication":{"$ref":"#/$defs/ApplicationPublicationReceipt"},"checkout":{"$ref":"#/$defs/PublicationCheckoutObservation"}},"additionalProperties":false},"RecoverApplicationCall":{"type":"object","required":["kind","readiness"],"properties":{"kind":{"const":"recover-application"},"readiness":{"$ref":"#/$defs/ReadinessHandle"},"action":{"enum":["observe","complete-publication"],"description":"Omit or select observe to reconcile only. Explicit complete-publication revalidates and attempts the same admitted candidate against its original expected target; it requires current publication authorization."}},"additionalProperties":false,"description":"Recover an admitted application. Observation performs no Git writes. Explicit completion reconstructs and verifies the exact admitted candidate before one compare-and-swap attempt."},"RecoverApplicationResult":{"type":"object","required":["kind","application","status","publication","checkout"],"properties":{"kind":{"const":"recover-application-result"},"application":{"$ref":"#/$defs/ApplicationHandle"},"status":{"const":"applied"},"publication":{"$ref":"#/$defs/ApplicationPublicationReceipt"},"checkout":{"$ref":"#/$defs/PublicationCheckoutObservation"}},"additionalProperties":false},"ApplicationRecoveryRequiredResult":{"type":"object","required":["kind","application","status","code","outcome","message","publication","checkout"],"properties":{"kind":{"const":"application-recovery-required-result"},"application":{"$ref":"#/$defs/ApplicationHandle"},"status":{"const":"recovery-required"},"code":{"enum":["APPLICATION.PUBLICATION_UNAVAILABLE","APPLICATION.OBSERVATION_UNAVAILABLE","APPLICATION.OUTCOME_OBSERVATION_UNAVAILABLE","APPLICATION.OUTCOME_PERSISTENCE_UNAVAILABLE","APPLICATION.RECOVERY_TARGET_UNCERTAIN","APPLICATION.RECOVERY_TARGET_DIVERGED","APPLICATION.RECOVERY_BLOCKED"]},"outcome":{"const":"unavailable"},"message":{"$ref":"#/$defs/NonEmptyString"},"publication":{"$ref":"#/$defs/ApplicationPublicationReceipt"},"checkout":{"$ref":"#/$defs/PublicationCheckoutObservation"},"details":{"type":"object","additionalProperties":{"$ref":"#/$defs/ScalarValue"}}},"additionalProperties":false},"PublicationTargetObservation":{"description":"Fresh bounded observation of the configured target ref; an unavailable revision is null.","type":"object","required":["kind","status","revision"],"properties":{"kind":{"const":"publication-target-observation"},"status":{"enum":["candidate","expected","diverged","unavailable"]},"revision":{"oneOf":[{"$ref":"#/$defs/GitObjectId"},{"type":"null"}]}},"additionalProperties":false},"ApplicationPublicationReceipt":{"description":"Durable application identity and exact candidate facts, separate from the fresh target observation.","type":"object","required":["kind","application","candidate_commit","candidate_tree","target_ref","expected_predecessor","durable_state","target_observation"],"properties":{"kind":{"const":"application-publication-receipt"},"application":{"$ref":"#/$defs/ApplicationHandle"},"candidate_commit":{"$ref":"#/$defs/GitObjectId"},"candidate_tree":{"oneOf":[{"$ref":"#/$defs/GitObjectId"},{"type":"null"}]},"target_ref":{"const":"refs/heads/main"},"expected_predecessor":{"$ref":"#/$defs/GitObjectId"},"durable_state":{"enum":["applied","admitted","unknown"]},"target_observation":{"$ref":"#/$defs/PublicationTargetObservation"}},"additionalProperties":false},"PublicationPathCounts":{"type":"object","required":["predecessor","candidate","conflicted"],"properties":{"predecessor":{"type":["integer","null"],"minimum":0},"candidate":{"type":["integer","null"],"minimum":0},"conflicted":{"type":["integer","null"],"minimum":0}},"additionalProperties":false},"PublicationCheckoutObservation":{"description":"Fresh read-only observation of one selected checkout. Unavailable observations use null for every fact that could not be established.","type":"object","required":["kind","status","worktree_id","symbolic_branch","head","index_observation","publication_path_count","index_paths","worktree_paths"],"properties":{"kind":{"const":"publication-checkout-observation"},"status":{"enum":["not-observed","unavailable","not-target-checkout","current","needs-reconciliation","conflicted"]},"worktree_id":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"symbolic_branch":{"oneOf":[{"$ref":"#/$defs/NonEmptyString"},{"type":"null"}]},"head":{"oneOf":[{"$ref":"#/$defs/GitObjectId"},{"type":"null"}]},"index_observation":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"publication_path_count":{"type":["integer","null"],"minimum":0},"index_paths":{"$ref":"#/$defs/PublicationPathCounts"},"worktree_paths":{"$ref":"#/$defs/PublicationPathCounts"}},"additionalProperties":false},"PolicySummary":{"type":"object","required":["handle","authority","scope"],"properties":{"handle":{"$ref":"#/$defs/SnapshotChildHandle"},"authority":{"enum":["normative","projection","contextual","evidence"]},"scope":{"$ref":"#/$defs/ReviewScope"}},"additionalProperties":false},"RelationshipSummary":{"type":"object","required":["handle","source","target","relation","groups","direction","traversal_eligible","applicability"],"properties":{"handle":{"$ref":"#/$defs/SnapshotChildHandle"},"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"relation":{"$ref":"#/$defs/CanonicalId"},"groups":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"minItems":1,"uniqueItems":true},"direction":{"enum":["incoming","outgoing"]},"traversal_eligible":{"type":"boolean"},"applicability":{"enum":["true","false","unknown","not-declared"]}},"additionalProperties":false},"ProposalPolicySummary":{"type":"object","required":["id","authority","scope"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"authority":{"enum":["normative","projection","contextual","evidence"]},"scope":{"$ref":"#/$defs/ReviewScope"}},"additionalProperties":false},"ProposalRelationshipSummary":{"type":"object","required":["source","target","relation","groups","direction","traversal_eligible","applicability"],"properties":{"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"relation":{"$ref":"#/$defs/CanonicalId"},"groups":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"minItems":1,"uniqueItems":true},"direction":{"enum":["incoming","outgoing"]},"traversal_eligible":{"type":"boolean"},"applicability":{"enum":["true","false","unknown","not-declared"]}},"additionalProperties":false},"RouteResult":{"type":"object","required":["kind","snapshot","reading_plan","unresolved_questions","next_operations"],"properties":{"kind":{"const":"route-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/Question"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"ReadResult":{"type":"object","required":["kind","snapshot","policy","content","requires","specializes","related","next_operations"],"properties":{"kind":{"const":"read-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"policy":{"$ref":"#/$defs/PolicySummary"},"content":{"type":"string"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"related":{"type":"array","items":{"$ref":"#/$defs/RelationshipSummary"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"},"routing":{"$ref":"#/$defs/RoutingConfiguration"},"coverage":{"$ref":"#/$defs/ReadCoverage"},"application_exposure":{"$ref":"#/$defs/ApplicationExposureState"},"provenance":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"PolicyUnitMapping":{"type":"object","required":["state","policy_units"],"properties":{"state":{"enum":["exact-policy-unit","policy-units-present","incomplete"]},"reason":{"const":"no-policy-units"},"policy_units":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true}},"additionalProperties":false},"RelatedResult":{"type":"object","required":["kind","snapshot","target","policy_unit_mapping","relationships","next_operations"],"properties":{"kind":{"const":"related-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"target":{"$ref":"#/$defs/CanonicalId"},"authoring_target":{"$ref":"#/$defs/AuthoringTargetHandle"},"policy_unit_mapping":{"$ref":"#/$defs/PolicyUnitMapping"},"relationships":{"type":"array","items":{"$ref":"#/$defs/RelationshipSummary"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"QueryResult":{"oneOf":[{"$ref":"#/$defs/RouteResult"},{"$ref":"#/$defs/ReadResult"},{"$ref":"#/$defs/RelatedResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/OperationalReadResult"}]},"ProposalRouteResult":{"type":"object","required":["kind","revision","reading_plan","unresolved_questions","next_operations"],"properties":{"kind":{"const":"proposal-route-result"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/Question"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/QueryProposalNextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"ProposalReadResult":{"type":"object","required":["kind","revision","policy","content","requires","specializes","related","next_operations"],"properties":{"kind":{"const":"proposal-read-result"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"policy":{"$ref":"#/$defs/ProposalPolicySummary"},"content":{"type":"string"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"related":{"type":"array","items":{"$ref":"#/$defs/ProposalRelationshipSummary"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/QueryProposalNextOperation"}},"summary":{"type":"string"},"routing":{"$ref":"#/$defs/RoutingConfiguration"},"coverage":{"$ref":"#/$defs/ReadCoverage"},"application_exposure":{"$ref":"#/$defs/ApplicationExposureState"},"provenance":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"ProposalRelatedResult":{"type":"object","required":["kind","revision","target","policy_unit_mapping","relationships","next_operations"],"properties":{"kind":{"const":"proposal-related-result"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"target":{"$ref":"#/$defs/CanonicalId"},"authoring_target":{"$ref":"#/$defs/AuthoringTargetHandle"},"policy_unit_mapping":{"$ref":"#/$defs/PolicyUnitMapping"},"relationships":{"type":"array","items":{"$ref":"#/$defs/ProposalRelationshipSummary"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/QueryProposalNextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"QueryProposalResult":{"oneOf":[{"$ref":"#/$defs/ProposalRouteResult"},{"$ref":"#/$defs/ProposalReadResult"},{"$ref":"#/$defs/ProposalRelatedResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/OperationalReadResult"}]},"AnalysisRequest":{"type":"object","required":["kind","base_snapshot","proposed_snapshot","changes","semantic_proposals","contract_version"],"properties":{"kind":{"const":"analysis-request"},"base_snapshot":{"$ref":"#/$defs/SnapshotHandle"},"proposed_snapshot":{"$ref":"#/$defs/SnapshotHandle"},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"},"minItems":1},"semantic_proposals":{"type":"array","items":{"$ref":"#/$defs/SemanticProposal"},"uniqueItems":true},"prior_analysis":{"$ref":"#/$defs/AnalysisHandle"},"contract_version":{"const":6}},"additionalProperties":false},"PrepareCall":{"type":"object","required":["request"],"properties":{"request":{"$ref":"#/$defs/AnalysisRequest"}},"additionalProperties":false},"AnalysisContext":{"type":"object","required":["kind","handle","subjects","changes","semantic_proposals"],"properties":{"kind":{"const":"analysis-context"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"subjects":{"type":"array","items":{"$ref":"#/$defs/ChangedPolicyUnit"},"uniqueItems":true},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"},"minItems":1,"uniqueItems":true},"semantic_proposals":{"type":"array","items":{"$ref":"#/$defs/SemanticProposal"},"uniqueItems":true}},"additionalProperties":false},"AuthorizationReference":{"type":"object","required":["id","issuer","capability","authority_digest"],"properties":{"id":{"$ref":"#/$defs/AuthorizationId"},"issuer":{"$ref":"#/$defs/CanonicalId"},"capability":{"$ref":"#/$defs/CanonicalId"},"authority_digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"ProviderReference":{"type":"object","required":["id","contract","contract_version","input_digest"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"contract":{"$ref":"#/$defs/CanonicalId"},"contract_version":{"$ref":"#/$defs/NonEmptyString"},"input_digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"AuthorizationRecord":{"type":"object","required":["reference","issuer_semantic_revision","principal","action","subject_kind","subject_id","authorization_evidence","revocation_authority","revocation_authority_semantic_revision","revocation_evidence"],"properties":{"reference":{"$ref":"#/$defs/AuthorizationReference"},"issuer_semantic_revision":{"type":"integer","minimum":1},"principal":{"$ref":"#/$defs/CanonicalId"},"action":{"$ref":"#/$defs/CanonicalId"},"subject_kind":{"$ref":"#/$defs/CanonicalId"},"subject_id":{"$ref":"#/$defs/NonEmptyString"},"authorization_evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true},"revocation_authority":{"$ref":"#/$defs/CanonicalId"},"revocation_authority_semantic_revision":{"type":"integer","minimum":1},"revocation_evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true}},"additionalProperties":false},"DomainContractReference":{"type":"object","required":["id","version"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"version":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"AnalysisExecutionContractView":{"type":"object","required":["authorization_authority_digest","providers"],"properties":{"authorization_authority_digest":{"oneOf":[{"$ref":"#/$defs/Digest"},{"type":"null"}]},"providers":{"type":"array","items":{"$ref":"#/$defs/ProviderReference"},"uniqueItems":true}},"additionalProperties":false},"FactRequirement":{"type":"object","required":["kind","handle","fact","fact_semantic_revision","fact_contract_digest","context","value_contract","answer_contract","evidence_contract","authorization_capability"],"properties":{"kind":{"const":"fact-requirement"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"fact":{"$ref":"#/$defs/CanonicalId"},"fact_semantic_revision":{"type":"integer","minimum":1},"fact_contract_digest":{"$ref":"#/$defs/Digest"},"context":{"$ref":"#/$defs/AnalysisChildHandle"},"value_contract":{"$ref":"#/$defs/FactValueContract"},"answer_contract":{"$ref":"#/$defs/CanonicalId"},"evidence_contract":{"$ref":"#/$defs/CanonicalId"},"authorization_capability":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"FactRequirementWork":{"type":"object","required":["requirement","prompt","dependent_programs"],"properties":{"requirement":{"$ref":"#/$defs/FactRequirement"},"prompt":{"$ref":"#/$defs/NonEmptyString"},"dependent_programs":{"type":"array","items":{"$ref":"#/$defs/NonEmptyString"},"minItems":1,"uniqueItems":true}},"additionalProperties":false},"FactObservation":{"type":"object","required":["kind","handle","requirement","value","evidence","authorization"],"properties":{"kind":{"const":"fact-observation"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"value":{"$ref":"#/$defs/FactValue"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true},"authorization":{"$ref":"#/$defs/AuthorizationReference"},"provider":{"$ref":"#/$defs/ProviderReference"}},"additionalProperties":false},"Obligation":{"type":"object","required":["handle","kind","target","scope","reasons","state","permitted_submissions","fingerprint"],"properties":{"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"kind":{"enum":["consumer-review","impact-review","lifecycle-impact-review","audit-coverage","unmapped-normative-change"]},"target":{"$ref":"#/$defs/CanonicalId"},"scope":{"$ref":"#/$defs/ReviewScope"},"reasons":{"type":"array","items":{"$ref":"#/$defs/SelectionReason"},"minItems":1,"uniqueItems":true},"state":{"enum":["required","resolved","blocked"]},"applicability":{"enum":["true","false","unknown","not-declared"]},"permitted_submissions":{"type":"array","items":{"enum":["consumer-disposition","impact-disposition","coverage-attestation"]},"minItems":1,"uniqueItems":true},"review_contract":{"$ref":"#/$defs/ConsumerReviewContract"},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"ProvideFactSubmission":{"type":"object","required":["kind","requirement","value","evidence"],"properties":{"kind":{"const":"provide-fact"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"value":{"$ref":"#/$defs/FactValue"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true}},"additionalProperties":false},"ConsumerDispositionSubmission":{"type":"object","required":["kind","obligation","result","rationale","evidence","fingerprint"],"properties":{"kind":{"const":"consumer-disposition"},"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"result":{"enum":["updated","reviewed-no-change","not-applicable","blocked"]},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"ImpactDispositionSubmission":{"type":"object","required":["kind","obligation","result","rationale","evidence","fingerprint"],"properties":{"kind":{"const":"impact-disposition"},"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"result":{"enum":["confirmed","resolved-no-impact","requires-change","blocked"]},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"CoverageAttestationClaim":{"type":"object","required":["requirement","conclusion","evidence","explicit_exclusions","rationale","auditor_provenance"],"properties":{"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"conclusion":{"const":"complete"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1,"uniqueItems":true},"explicit_exclusions":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"uniqueItems":true},"rationale":{"$ref":"#/$defs/NonEmptyString"},"auditor_provenance":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"CoverageAttestationSubmission":{"type":"object","required":["kind","claim"],"properties":{"kind":{"const":"coverage-attestation"},"claim":{"$ref":"#/$defs/CoverageAttestationClaim"}},"additionalProperties":false},"Submission":{"oneOf":[{"$ref":"#/$defs/ProvideFactSubmission"},{"$ref":"#/$defs/ConsumerDispositionSubmission"},{"$ref":"#/$defs/ImpactDispositionSubmission"},{"$ref":"#/$defs/CoverageAttestationSubmission"}]},"ResolveCall":{"type":"object","required":["analysis","submission"],"properties":{"analysis":{"$ref":"#/$defs/AnalysisHandle"},"submission":{"$ref":"#/$defs/Submission"}},"additionalProperties":false},"CoverageRequirement":{"type":"object","required":["kind","handle","subject","owner","semantic_revision","relationship_kinds","horizon","required_evidence_contract"],"properties":{"kind":{"const":"coverage-requirement"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"subject":{"$ref":"#/$defs/CanonicalId"},"owner":{"$ref":"#/$defs/CanonicalId"},"semantic_revision":{"type":"integer","minimum":1},"relationship_kinds":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"horizon":{"$ref":"#/$defs/CanonicalId"},"required_evidence_contract":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"CoverageAttestation":{"type":"object","required":["kind","requirement","conclusion","evidence","explicit_exclusions","rationale","auditor_provenance","schema_version","authorization"],"properties":{"kind":{"const":"coverage-attestation"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"conclusion":{"const":"complete"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1},"explicit_exclusions":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"}},"rationale":{"$ref":"#/$defs/NonEmptyString"},"auditor_provenance":{"$ref":"#/$defs/NonEmptyString"},"schema_version":{"const":4},"authorization":{"$ref":"#/$defs/AuthorizationReference"}},"additionalProperties":false},"CoverageCertificate":{"type":"object","required":["kind","handle","requirement","subject","owner","semantic_revision","horizon_digest","relationship_digest","evidence_digests","fact_schema_digest"],"properties":{"kind":{"const":"coverage-certificate"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"subject":{"$ref":"#/$defs/CanonicalId"},"owner":{"$ref":"#/$defs/CanonicalId"},"semantic_revision":{"type":"integer","minimum":1},"horizon_digest":{"$ref":"#/$defs/Digest"},"relationship_digest":{"$ref":"#/$defs/Digest"},"evidence_digests":{"type":"array","items":{"$ref":"#/$defs/Digest"},"uniqueItems":true},"fact_schema_digest":{"$ref":"#/$defs/Digest"}},"additionalProperties":false},"DispositionRecord":{"type":"object","required":["obligation","kind","result","rationale","evidence","authorization","fingerprint"],"properties":{"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"kind":{"enum":["consumer-disposition","impact-disposition"]},"result":{"$ref":"#/$defs/NonEmptyString"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"}},"authorization":{"$ref":"#/$defs/AuthorizationReference"},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"AnalysisState":{"type":"object","required":["kind","handle","base_snapshot","proposed_reference","changes","semantic_proposals","fact_observations","dispositions","coverage_attestations","authorization_records","domain_contracts","execution_contracts","contract_version"],"properties":{"kind":{"const":"analysis-state"},"handle":{"$ref":"#/$defs/AnalysisHandle"},"base_snapshot":{"$ref":"#/$defs/SnapshotHandle"},"proposed_reference":{"$ref":"#/$defs/AnalysisMaterialHandle"},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"},"minItems":1,"uniqueItems":true},"semantic_proposals":{"type":"array","items":{"$ref":"#/$defs/SemanticProposal"},"uniqueItems":true},"fact_observations":{"type":"array","items":{"$ref":"#/$defs/FactObservation"},"uniqueItems":true},"dispositions":{"type":"array","items":{"$ref":"#/$defs/DispositionRecord"},"uniqueItems":true},"coverage_attestations":{"type":"array","items":{"$ref":"#/$defs/CoverageAttestation"},"uniqueItems":true},"authorization_records":{"type":"array","items":{"$ref":"#/$defs/AuthorizationRecord"},"uniqueItems":true},"domain_contracts":{"type":"array","items":{"$ref":"#/$defs/DomainContractReference"},"minItems":1,"uniqueItems":true},"execution_contracts":{"$ref":"#/$defs/AnalysisExecutionContractView"},"contract_version":{"const":7}},"additionalProperties":false},"PendingResult":{"type":"object","required":["kind","handle","status","context","changes","changed_units","obligations","fact_requirements","reading_plan","next_operations"],"properties":{"kind":{"const":"pending-result"},"handle":{"$ref":"#/$defs/AnalysisHandle"},"status":{"const":"needs-action"},"context":{"$ref":"#/$defs/AnalysisContext"},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"}},"changed_units":{"type":"array","items":{"$ref":"#/$defs/ChangedPolicyUnit"}},"obligations":{"type":"array","items":{"$ref":"#/$defs/Obligation"}},"fact_requirements":{"type":"array","items":{"$ref":"#/$defs/FactRequirementWork"}},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"}},"additionalProperties":false},"CompleteResult":{"type":"object","required":["kind","handle","status","context","changes","changed_units","coverage_certificates","fact_observations","dispositions","reading_plan","completion"],"properties":{"kind":{"const":"complete-result"},"handle":{"$ref":"#/$defs/AnalysisHandle"},"status":{"const":"complete"},"context":{"$ref":"#/$defs/AnalysisContext"},"changes":{"type":"array","items":{"$ref":"#/$defs/ChangeDescriptor"}},"changed_units":{"type":"array","items":{"$ref":"#/$defs/ChangedPolicyUnit"}},"coverage_certificates":{"type":"array","items":{"$ref":"#/$defs/CoverageCertificate"},"uniqueItems":true},"fact_observations":{"type":"array","items":{"$ref":"#/$defs/FactObservation"},"uniqueItems":true},"dispositions":{"type":"array","items":{"$ref":"#/$defs/DispositionRecord"}},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"completion":{"$ref":"#/$defs/CompletionProof"},"summary":{"type":"string"}},"additionalProperties":false},"RepositoryPath":{"type":"array","items":{"$ref":"#/$defs/NonEmptyString"},"minItems":1},"ProvenanceRecord":{"type":"object","required":["snapshot","path"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"path":{"$ref":"#/$defs/RepositoryPath"}},"additionalProperties":false},"SnapshotInspectionResult":{"type":"object","required":["kind","snapshot"],"properties":{"kind":{"const":"snapshot-inspection-result"},"snapshot":{"$ref":"#/$defs/SnapshotSummary"}},"additionalProperties":false},"PolicyInspectionResult":{"type":"object","required":["kind","policy","declaration","representation_digest","structural_digest","provenance"],"properties":{"kind":{"const":"policy-inspection-result"},"policy":{"$ref":"#/$defs/SnapshotChildHandle"},"declaration":{"oneOf":[{"$ref":"#/$defs/CanonicalModuleDeclaration"},{"$ref":"#/$defs/PolicyUnitDeclaration"}]},"representation_digest":{"$ref":"#/$defs/Digest"},"structural_digest":{"$ref":"#/$defs/Digest"},"provenance":{"$ref":"#/$defs/ProvenanceRecord"}},"additionalProperties":false},"RelationshipInspectionResult":{"type":"object","required":["kind","relationship","policy_semantics","provenance"],"properties":{"kind":{"const":"relationship-inspection-result"},"relationship":{"$ref":"#/$defs/RelationshipSummary"},"policy_semantics":{"oneOf":[{"$ref":"#/$defs/PolicyRelationshipInspection"},{"type":"null"}]},"provenance":{"$ref":"#/$defs/ProvenanceRecord"}},"additionalProperties":false},"AnalysisInspectionResult":{"type":"object","required":["kind","state"],"properties":{"kind":{"const":"analysis-inspection-result"},"state":{"$ref":"#/$defs/AnalysisState"}},"additionalProperties":false},"AnalysisChildArtifact":{"oneOf":[{"$ref":"#/$defs/AnalysisContext"},{"$ref":"#/$defs/FactRequirement"},{"$ref":"#/$defs/FactObservation"},{"$ref":"#/$defs/Obligation"},{"$ref":"#/$defs/CoverageRequirement"},{"$ref":"#/$defs/CoverageCertificate"}]},"AnalysisChildInspectionResult":{"type":"object","required":["kind","handle","artifact"],"properties":{"kind":{"const":"analysis-child-inspection-result"},"handle":{"$ref":"#/$defs/AnalysisChildHandle"},"artifact":{"$ref":"#/$defs/AnalysisChildArtifact"}},"additionalProperties":false},"InspectionResult":{"oneOf":[{"$ref":"#/$defs/SnapshotInspectionResult"},{"$ref":"#/$defs/PolicyInspectionResult"},{"$ref":"#/$defs/RelationshipInspectionResult"},{"$ref":"#/$defs/AnalysisInspectionResult"},{"$ref":"#/$defs/AnalysisChildInspectionResult"}]},"InspectCall":{"type":"object","required":["handle"],"properties":{"handle":{"$ref":"#/$defs/InspectableHandle"}},"additionalProperties":false},"RejectedResult":{"type":"object","required":["kind","code","outcome","message","details","next_operations"],"properties":{"kind":{"const":"rejected-result"},"code":{"$ref":"#/$defs/CanonicalId"},"outcome":{"enum":["invalid","unavailable","unsupported","unauthorized"]},"target":{"$ref":"#/$defs/NonEmptyString"},"message":{"$ref":"#/$defs/NonEmptyString"},"details":{"type":"object","additionalProperties":{"$ref":"#/$defs/ScalarValue"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"input_feedback":{"$ref":"#/$defs/InputFeedback"},"relationship_groups":{"$ref":"#/$defs/RelationshipGroupsResult"}},"additionalProperties":false},"AuthoredRoutingRule":{"type":"object","required":["id","target","when","condition"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"when":{"$ref":"#/$defs/ApplicabilityExpression"},"condition":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"AuthoredRoutingFact":{"type":"object","required":["id","semantic_revision","type","nullable","values","aliases","meaning","prompt"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"semantic_revision":{"type":"integer","minimum":1},"type":{"enum":["boolean","enum","string","string-set","enum-set","canonical-id"]},"nullable":{"type":"boolean"},"values":{"type":"array","items":{"type":"string"},"uniqueItems":true},"aliases":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"meaning":{"$ref":"#/$defs/NonEmptyString"},"prompt":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PutRoutingRuleEdit":{"type":"object","required":["kind","rule","rationale"],"properties":{"kind":{"const":"put-routing-rule"},"rule":{"$ref":"#/$defs/AuthoredRoutingRule"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"RemoveRoutingRuleEdit":{"type":"object","required":["kind","rule","rationale"],"properties":{"kind":{"const":"remove-routing-rule"},"rule":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"PutRoutingFactEdit":{"type":"object","required":["kind","fact","rationale"],"properties":{"kind":{"const":"put-routing-fact"},"fact":{"$ref":"#/$defs/AuthoredRoutingFact"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"RemoveRoutingFactEdit":{"type":"object","required":["kind","fact","rationale"],"properties":{"kind":{"const":"remove-routing-fact"},"fact":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"VerificationFailure":{"type":"object","additionalProperties":false,"required":["code","message","suite","check"],"properties":{"code":{"$ref":"#/$defs/NonEmptyString"},"message":{"$ref":"#/$defs/NonEmptyString"},"suite":{"type":["string","null"]},"check":{"type":["string","null"]}}},"VerificationReport":{"type":"object","additionalProperties":false,"required":["passed","exit_code","suites","checks","failures"],"properties":{"passed":{"type":"boolean"},"exit_code":{"enum":[0,1,2,3,4]},"suites":{"type":"integer","minimum":0},"checks":{"type":"integer","minimum":0},"failures":{"type":"array","items":{"$ref":"#/$defs/VerificationFailure"}}}},"VerifyRepositoryCall":{"type":"object","additionalProperties":false,"required":["kind","refresh_verification_inputs"],"properties":{"kind":{"const":"verify-repository"},"refresh_verification_inputs":{"type":"boolean"}}},"VerifyRepositoryResult":{"type":"object","additionalProperties":false,"required":["kind","refreshed_verification_inputs","verification"],"properties":{"kind":{"const":"verify-repository-result"},"refreshed_verification_inputs":{"type":"boolean"},"verification":{"$ref":"#/$defs/VerificationReport"}}},"VerifyProposalCall":{"type":"object","additionalProperties":false,"required":["kind","revision"],"properties":{"kind":{"const":"verify-proposal"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"readiness":{"$ref":"#/$defs/ReadinessHandle"}}},"VerifyProposalResult":{"type":"object","additionalProperties":false,"required":["kind","revision","verification"],"properties":{"kind":{"const":"verify-proposal-result"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"verification":{"$ref":"#/$defs/VerificationReport"},"readiness":{"$ref":"#/$defs/ReadinessHandle"}}},"RoutingConfiguration":{"type":"object","additionalProperties":false,"required":["facts","rules"],"properties":{"facts":{"type":"array","items":{"$ref":"#/$defs/AuthoredRoutingFact"}},"rules":{"type":"array","items":{"$ref":"#/$defs/AuthoredRoutingRule"}}}},"PolicyCoverageStatus":{"type":"object","required":["subject","requirement_id","status"],"properties":{"subject":{"$ref":"#/$defs/CanonicalId"},"requirement_id":{"$ref":"#/$defs/Digest"},"status":{"enum":["current-attestation","review-required"]},"authority":{"$ref":"#/$defs/CoverageAuditAuthority"}},"additionalProperties":false},"ReadCoverage":{"type":"object","description":"Repository attestation status bound to this snapshot or proposal. Empty subjects means no registered policy units in scope, not complete coverage. Analysis-local attestations are not repository certificates.","required":["subjects"],"properties":{"subjects":{"type":"array","items":{"$ref":"#/$defs/PolicyCoverageStatus"}}},"additionalProperties":false},"AuditPolicyUnitEdit":{"type":"object","required":["kind","policy","rationale"],"properties":{"kind":{"const":"audit-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"rationale":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"CoverageAuditAuthority":{"type":"object","required":["issuer","principal","authorization_id"],"properties":{"issuer":{"$ref":"#/$defs/NonEmptyString"},"principal":{"$ref":"#/$defs/NonEmptyString"},"authorization_id":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"EvidenceCheckRetirement":{"type":"object","additionalProperties":false,"required":["suite","check"],"properties":{"suite":{"type":"string","minLength":1},"check":{"type":"string","minLength":1}}},"EvidenceSuiteDescription":{"type":"object","additionalProperties":false,"required":["suite","description"],"properties":{"suite":{"type":"string","minLength":1},"description":{"type":"string","minLength":1}}},"EvidenceRelationshipUpdate":{"type":"object","additionalProperties":false,"required":["source_policy","consumer","relation","evidence_owner","rationale"],"properties":{"source_policy":{"type":"string","minLength":1},"consumer":{"type":"string","minLength":1},"relation":{"type":"string","minLength":1},"evidence_owner":{"type":"string","minLength":1},"rationale":{"type":"string","minLength":1}}},"EvidenceConsumerRegistration":{"type":"object","additionalProperties":false,"required":["path","artifact_kind","source_policies","relation","evidence_owner","rationale"],"properties":{"path":{"type":"string","minLength":1},"artifact_kind":{"type":"string","enum":["implementation-artifact","fixture"]},"source_policies":{"type":"array","items":{"type":"string","minLength":1},"minItems":1,"uniqueItems":true},"relation":{"type":"string","enum":["implementation-projection","fixture-projection"]},"evidence_owner":{"type":"string","minLength":1},"rationale":{"type":"string","minLength":1}}},"EngineCertificateRetirement":{"type":"object","additionalProperties":false,"required":["subject","requirement_id","rationale"],"properties":{"subject":{"$ref":"#/$defs/CanonicalId"},"requirement_id":{"$ref":"#/$defs/Digest"},"rationale":{"$ref":"#/$defs/NonEmptyString"}}},"EvidenceMaintenancePlan":{"type":"object","additionalProperties":false,"required":["prune_stale_certificates","retire_suites","retire_checks","retire_inputs","suite_descriptions","replacement_evidence_owner","replacement_evidence_rationale","relationship_updates","consumer_registrations"],"properties":{"retire_engine_certificates":{"type":"array","items":{"$ref":"#/$defs/EngineCertificateRetirement"},"uniqueItems":true,"description":"Explicitly retire exact registered Engine-issued certificates by subject and requirement; preserve normative policy and consumer registrations."},"prune_stale_certificates":{"type":"boolean"},"retire_suites":{"type":"array","items":{"type":"string","minLength":1},"uniqueItems":true},"retire_checks":{"type":"array","items":{"$ref":"#/$defs/EvidenceCheckRetirement"}},"retire_inputs":{"type":"array","items":{"type":"string","minLength":1},"uniqueItems":true},"suite_descriptions":{"type":"array","items":{"$ref":"#/$defs/EvidenceSuiteDescription"}},"replacement_evidence_owner":{"type":"string","minLength":1},"replacement_evidence_rationale":{"type":"string","minLength":1},"relationship_updates":{"type":"array","items":{"$ref":"#/$defs/EvidenceRelationshipUpdate"}},"consumer_registrations":{"type":"array","items":{"$ref":"#/$defs/EvidenceConsumerRegistration"}},"unregister_policy_subjects":{"type":"array","items":{"type":"string","minLength":1},"uniqueItems":true,"description":"Remove selected review-subject registrations and their source relationships while preserving normative Markdown."}}},"MaintainEvidenceCall":{"type":"object","additionalProperties":false,"required":["kind","expected_revision","evidence","plan","apply"],"properties":{"kind":{"const":"maintain-evidence"},"expected_revision":{"type":"string","minLength":1},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"},"minItems":1},"plan":{"$ref":"#/$defs/EvidenceMaintenancePlan"},"apply":{"type":"boolean"}}},"MaintainEvidenceResult":{"type":"object","additionalProperties":false,"required":["kind","applied","changed_files","removed_files","verification"],"properties":{"kind":{"const":"maintain-evidence-result"},"applied":{"type":"boolean"},"changed_files":{"type":"array","items":{"type":"string","minLength":1}},"removed_files":{"type":"array","items":{"type":"string","minLength":1}},"verification":{"$ref":"#/$defs/VerificationReport"}}},"RouteCall":{"type":"object","required":["facts"],"properties":{"facts":{"$ref":"#/$defs/RoutingFactAssertions"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"content":{"$ref":"#/$defs/RouteContentSelection"},"detail":{"enum":["compact","full"],"description":"Compact authoring selection is default. Full returns the rule explanation. Application always retains its qualified projection."}},"additionalProperties":false},"ReadCall":{"type":"object","required":["target"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"include_routing":{"type":"boolean"},"include_coverage":{"type":"boolean","description":"Include current repository attestation status for registered policy units in this read scope."},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"detail":{"enum":["compact","full"],"description":"Compact preserves exact policy and essential authority; full includes all relationship rows."}},"additionalProperties":false},"RelatedCall":{"type":"object","required":["target","groups","direction","transitive"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"groups":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"direction":{"enum":["incoming","outgoing","both"]},"transitive":{"type":"boolean","default":false},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"CompactReadResult":{"type":"object","required":["kind","snapshot","policy","content","requires","specializes","next_operations","detail"],"properties":{"kind":{"const":"compact-read-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"policy":{"$ref":"#/$defs/PolicySummary"},"content":{"type":"string"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"},"routing":{"$ref":"#/$defs/RoutingConfiguration"},"coverage":{"$ref":"#/$defs/ReadCoverage"},"detail":{"const":"compact"},"application_exposure":{"$ref":"#/$defs/ApplicationExposureState"},"provenance":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}}},"additionalProperties":false},"RoutingFactsCall":{"type":"object","additionalProperties":false,"required":[],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"}}},"RoutingFactsResult":{"type":"object","additionalProperties":false,"required":["kind","snapshot","facts"],"properties":{"kind":{"const":"routing-facts-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"facts":{"type":"array","items":{"$ref":"#/$defs/AuthoredRoutingFact"}}}},"RoutingQuestion":{"type":"object","additionalProperties":false,"required":["id","kind","prompt","state","fact"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"kind":{"const":"applicability-fact"},"prompt":{"$ref":"#/$defs/NonEmptyString"},"state":{"const":"required"},"fact":{"$ref":"#/$defs/AuthoredRoutingFact"}}},"RoutingRuleExplanation":{"type":"object","additionalProperties":false,"required":["id","target","when","state"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"when":{"$ref":"#/$defs/ApplicabilityExpression"},"state":{"enum":["selected","unresolved"]}}},"AgentRouteResult":{"type":"object","required":["kind","snapshot","reading_plan","unresolved_questions","next_operations","facts","rules"],"properties":{"kind":{"const":"agent-route-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/RoutingQuestion"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"},"facts":{"$ref":"#/$defs/RoutingFactAssertions"},"rules":{"type":"array","items":{"$ref":"#/$defs/RoutingRuleExplanation"}},"content":{"$ref":"#/$defs/RoutedContentPage"}},"additionalProperties":false},"WorkflowContext":{"oneOf":[{"$ref":"#/$defs/ProposalRevisionHandle"},{"$ref":"#/$defs/AnalysisHandle"},{"$ref":"#/$defs/ReadinessHandle"}]},"ProposeCall":{"type":"object","additionalProperties":false,"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"change_set":{"$ref":"#/$defs/StandardsChangeSet"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["change_set"]},"ReviseCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"change_set":{"$ref":"#/$defs/StandardsChangeSet"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context","change_set"]},"AnalyzeCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"]},"ResolveWorkflowCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"submission":{"$ref":"#/$defs/Submission"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context","submission"]},"ReviewCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"decisions":{"type":"array","minItems":3,"maxItems":3,"uniqueItems":true,"items":{"$ref":"#/$defs/ReviewDecision"}},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context","decisions"]},"ApplyCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"]},"RecoverCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"action":{"enum":["observe","complete-publication"],"description":"Omit or select observe to reconcile only. Explicit complete-publication revalidates and attempts the same admitted candidate against its original expected target; it requires current publication authorization."},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"],"description":"Recover an admitted application. Observation performs no Git writes. Explicit completion reconstructs and verifies the exact admitted candidate before one compare-and-swap attempt."},"WorkflowStatusCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"]},"ResumeCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."}},"required":["context"]},"WorkflowContinuation":{"type":"object","additionalProperties":false,"properties":{"operation":{"enum":["revise","analyze","resolve_workflow","review","apply","recover","workflow_status","resume","resolve_many"]},"required_inputs":{"type":"array","uniqueItems":true,"items":{"enum":["change_set","submission","decisions","action","submissions"]}}},"required":["operation","required_inputs"],"description":"Select the named operation with the enclosing WorkflowResult context and explicit required inputs. This descriptor is not an authorization grant."},"WorkflowOutcome":{"oneOf":[{"$ref":"#/$defs/CreateProposalResult"},{"$ref":"#/$defs/ReviseProposalResult"},{"$ref":"#/$defs/PendingResult"},{"$ref":"#/$defs/CompleteResult"},{"$ref":"#/$defs/ReviewProposalResult"},{"$ref":"#/$defs/ApplyProposalResult"},{"$ref":"#/$defs/ApplicationRecoveryRequiredResult"},{"$ref":"#/$defs/RecoverApplicationResult"},{"$ref":"#/$defs/RejectedResult"},{"$ref":"#/$defs/WorkflowAnalysisSummary"}]},"WorkflowResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"workflow-result"},"context":{"$ref":"#/$defs/WorkflowContext"},"proposal":{"$ref":"#/$defs/ProposalHandle"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"publication":{"$ref":"#/$defs/ApplicationPublicationReceipt"},"checkout":{"$ref":"#/$defs/PublicationCheckoutObservation"},"status":{"enum":["draft","needs-action","complete","requires-change","ready","recovery-required","applied","rejected","stale"]},"next_operations":{"type":"array","items":{"$ref":"#/$defs/WorkflowContinuation"}},"outcome":{"$ref":"#/$defs/WorkflowOutcome"},"work":{"oneOf":[{"$ref":"#/$defs/WorkflowWorkPage"},{"$ref":"#/$defs/WorkflowWorkDeferred"}]}},"required":["kind","context","proposal","revision","status","next_operations"],"description":"Exact immutable workflow context and relative action descriptors. Successful compact pending propose, revise, analyze and decision submissions include work from the already-produced Analysis. Status observations, full results, stale contexts and other outcomes omit work."},"FocusedQueryNextOperation":{"type":"object","required":["operation","request_kind","snapshot"],"properties":{"operation":{"enum":["route","read","related"]},"request_kind":{"enum":["route","read","related"]},"target":{"$ref":"#/$defs/CanonicalId"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"}},"additionalProperties":false},"RewriteNavigationIndexEdit":{"type":"object","required":["kind","entrypoint","destinations","rationale"],"properties":{"kind":{"const":"rewrite-navigation-index"},"entrypoint":{"$ref":"#/$defs/AuthoringTargetHandle"},"destinations":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"minItems":1,"uniqueItems":true},"rationale":{"$ref":"#/$defs/NonEmptyString"},"retargets":{"type":"array","items":{"$ref":"#/$defs/NavigationRetarget"},"uniqueItems":true}},"additionalProperties":false},"NavigationIndexEntry":{"type":"object","required":["id","entrypoint","destinations"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"entrypoint":{"$ref":"#/$defs/AuthoringTargetHandle"},"destinations":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"},"uniqueItems":true},"content":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"NavigationIndexesResult":{"type":"object","required":["kind","authority","indexes","next_operations"],"properties":{"kind":{"const":"navigation-indexes-result"},"authority":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/ProposalRevisionHandle"}]},"indexes":{"type":"array","items":{"$ref":"#/$defs/NavigationIndexEntry"},"minItems":1},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"},"maxItems":0}},"additionalProperties":false},"NavigationRetarget":{"type":"object","required":["entrypoint","standard"],"properties":{"entrypoint":{"$ref":"#/$defs/AuthoringTargetHandle"},"standard":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false},"ApplicationNextOperation":{"type":"object","additionalProperties":false,"required":["operation","snapshot"],"properties":{"operation":{"enum":["read","related","routing_facts","route","query","inspect"]},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"target":{"$ref":"#/$defs/CanonicalId"},"handle":{"$ref":"#/$defs/SnapshotChildHandle"}}},"ApplicationRejectedResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","code","outcome","message","next_operations"],"properties":{"kind":{"const":"application-rejected-result"},"purpose":{"const":"application"},"code":{"enum":["APPLICATION.UNKNOWN_TARGET","APPLICATION.INPUT_INVALID","APPLICATION.OPERATION_UNAVAILABLE","APPLICATION.INTERNAL_UNAVAILABLE","APPLICATION.UNSUPPORTED_CAPTURE","APPLICATION.RESULT_LIMIT","APPLICATION.UNKNOWN_GROUP","APPLICATION.TRAVERSAL_NOT_PERMITTED"]},"outcome":{"enum":["invalid","unsupported","unavailable"]},"message":{"type":"string"},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}},"input_feedback":{"$ref":"#/$defs/InputFeedback"},"relationship_groups":{"$ref":"#/$defs/RelationshipGroupsResult"}}},"ApplicationPolicy":{"type":"object","additionalProperties":false,"required":["id","handle","role","level"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"handle":{"$ref":"#/$defs/SnapshotChildHandle"},"role":{"enum":["core","router","topic","workflow","profile","reference","prompt","template","documentation"]},"level":{"enum":["MUST","SHOULD","PROFILE","REFERENCE"]}}},"ApplicationRelationship":{"type":"object","additionalProperties":false,"required":["handle","source","target","relation","groups","direction"],"properties":{"handle":{"$ref":"#/$defs/SnapshotChildHandle"},"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"relation":{"type":"string"},"groups":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"direction":{"enum":["incoming","outgoing"]}}},"ApplicationReadResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","snapshot","policy","review_state","content","scope","requires","specializes","next_operations"],"properties":{"kind":{"const":"application-read-result"},"purpose":{"const":"application"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"policy":{"$ref":"#/$defs/ApplicationPolicy"},"review_state":{"$ref":"#/$defs/ApplicationReviewState"},"content":{"type":"string"},"scope":{"$ref":"#/$defs/ReviewScope"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"related":{"type":"array","items":{"$ref":"#/$defs/ApplicationRelationship"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}}}},"ApplicationRelatedResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","snapshot","target","relationships","next_operations"],"properties":{"kind":{"const":"application-related-result"},"purpose":{"const":"application"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"target":{"$ref":"#/$defs/CanonicalId"},"relationships":{"type":"array","items":{"$ref":"#/$defs/ApplicationRelationship"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}}}},"ApplicationReadingEntry":{"type":"object","additionalProperties":false,"required":["target","scope","authority","state","review_state"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"scope":{"$ref":"#/$defs/ReviewScope"},"authority":{"enum":["normative","contextual"]},"state":{"const":"selected"},"review_state":{"$ref":"#/$defs/ApplicationReviewState"}}},"ApplicationQuestion":{"type":"object","additionalProperties":false,"required":["fact"],"properties":{"fact":{"$ref":"#/$defs/AuthoredRoutingFact"}}},"ApplicationRouteResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","snapshot","status","reading_plan","unresolved_questions","next_operations"],"properties":{"kind":{"const":"application-route-result"},"purpose":{"const":"application"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"status":{"enum":["complete","needs-facts"]},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ApplicationReadingEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/ApplicationQuestion"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}},"content":{"$ref":"#/$defs/ApplicationRoutedContentPage"}}},"ApplicationRoutingFactsResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","snapshot","facts","next_operations"],"properties":{"kind":{"const":"application-routing-facts-result"},"purpose":{"const":"application"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"facts":{"type":"array","items":{"$ref":"#/$defs/AuthoredRoutingFact"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/ApplicationNextOperation"}}}},"ApplicationReadCall":{"type":"object","additionalProperties":false,"required":["target"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"detail":{"enum":["compact","full"]}}},"ApplicationReadRequest":{"type":"object","additionalProperties":false,"required":["kind","target"],"properties":{"kind":{"const":"read"},"target":{"$ref":"#/$defs/CanonicalId"},"detail":{"enum":["compact","full"]}}},"ApplicationQueryRequest":{"oneOf":[{"$ref":"#/$defs/RouteRequest"},{"$ref":"#/$defs/ApplicationReadRequest"},{"$ref":"#/$defs/RelatedRequest"}]},"ApplicationQueryCall":{"type":"object","additionalProperties":false,"required":["snapshot","request"],"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"request":{"$ref":"#/$defs/ApplicationQueryRequest"}}},"ApplicationInspectCall":{"type":"object","additionalProperties":false,"required":["handle"],"properties":{"handle":{"$ref":"#/$defs/SnapshotChildHandle"}}},"AuthoredDecisionProvenance":{"type":"object","additionalProperties":false,"required":["id","subject","origin","rationale","evidence"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"subject":{"$ref":"#/$defs/CanonicalId"},"origin":{"enum":["documented-original","reconstructed-history","current-justification","unrecorded"]},"rationale":{"type":"string"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"}},"assumptions":{"type":"array","items":{"type":"string"}},"limits":{"type":"array","items":{"type":"string"}},"alternatives":{"type":"array","items":{"type":"string"}},"reconsideration":{"type":"array","items":{"type":"string"}},"supersedes":{"type":"array","items":{"type":"string"}}}},"DecisionProvenanceRecord":{"type":"object","additionalProperties":false,"required":["id","subject","origin","rationale","evidence","assumptions","limits","alternatives","reconsideration","supersedes","subject_binding","retired"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"subject":{"$ref":"#/$defs/CanonicalId"},"origin":{"enum":["documented-original","reconstructed-history","current-justification","unrecorded"]},"rationale":{"type":"string"},"evidence":{"type":"array","items":{"$ref":"#/$defs/EvidenceReference"}},"assumptions":{"type":"array","items":{"type":"string"}},"limits":{"type":"array","items":{"type":"string"}},"alternatives":{"type":"array","items":{"type":"string"}},"reconsideration":{"type":"array","items":{"type":"string"}},"supersedes":{"type":"array","items":{"type":"string"}},"subject_binding":{"$ref":"#/$defs/Digest"},"retired":{"type":"boolean"}}},"ApplicationExposureState":{"enum":["unreviewed","current","needs-review"]},"ApplicationReviewState":{"enum":["current","changed-since-review","not-reviewed"],"description":"Review label of delivered application material. current: this exact text was approved for application use. changed-since-review: the text was edited after its approval. not-reviewed: the text has never been approved. The label never withholds material; a scoped policy read carries the label of its containing module."},"ProvenanceReadResult":{"type":"object","additionalProperties":false,"required":["kind","authority","record","state","next_operations"],"properties":{"kind":{"const":"provenance-read-result"},"authority":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/ProposalRevisionHandle"}]},"record":{"$ref":"#/$defs/DecisionProvenanceRecord"},"state":{"enum":["current","needs-review","retired"]},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}}}},"OperationalReadResult":{"type":"object","additionalProperties":false,"required":["kind","authority","target","canonical_id","role","content","application_exposure","next_operations"],"properties":{"kind":{"const":"operational-read-result"},"authority":{"oneOf":[{"$ref":"#/$defs/SnapshotHandle"},{"$ref":"#/$defs/ProposalRevisionHandle"}]},"target":{"$ref":"#/$defs/AuthoringTargetHandle"},"canonical_id":{"$ref":"#/$defs/CanonicalId"},"role":{"enum":["prompt","template","documentation"]},"content":{"type":"string"},"application_exposure":{"$ref":"#/$defs/ApplicationExposureState"},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}}}},"PutDecisionProvenanceEdit":{"type":"object","additionalProperties":false,"required":["kind","record"],"properties":{"kind":{"const":"put-provenance"},"record":{"$ref":"#/$defs/AuthoredDecisionProvenance"}}},"RetireDecisionProvenanceEdit":{"type":"object","additionalProperties":false,"required":["kind","id"],"properties":{"kind":{"const":"retire-provenance"},"id":{"$ref":"#/$defs/CanonicalId"}}},"ApproveApplicationContentEdit":{"type":"object","additionalProperties":false,"required":["kind","target"],"properties":{"kind":{"const":"approve-application-content"},"target":{"oneOf":[{"$ref":"#/$defs/CanonicalId"},{"$ref":"#/$defs/AuthoringTargetHandle"}]}}},"WithdrawApplicationContentEdit":{"type":"object","additionalProperties":false,"required":["kind","target"],"properties":{"kind":{"const":"withdraw-application-content"},"target":{"oneOf":[{"$ref":"#/$defs/CanonicalId"},{"$ref":"#/$defs/AuthoringTargetHandle"}]}}},"ReviseOperationalArtifactEdit":{"type":"object","additionalProperties":false,"required":["kind","target","title","body"],"properties":{"kind":{"const":"revise-operational-artifact"},"target":{"oneOf":[{"$ref":"#/$defs/CanonicalId"},{"$ref":"#/$defs/AuthoringTargetHandle"}]},"title":{"$ref":"#/$defs/NonEmptyString"},"body":{"type":"string"}}},"PolicyScopeUpdate":{"type":"object","additionalProperties":false,"required":["policy","heading_path","semantics"],"properties":{"policy":{"$ref":"#/$defs/CanonicalId"},"heading_path":{"type":"array","minItems":1,"items":{"$ref":"#/$defs/NonEmptyString"}},"semantics":{"$ref":"#/$defs/PolicySemanticIntent"}}},"ReadManyItem":{"type":"object","required":["target"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"include_routing":{"type":"boolean"},"include_coverage":{"type":"boolean","description":"Include current repository attestation status for registered policy units in this read scope."},"detail":{"enum":["compact","full"],"description":"Compact preserves exact policy and essential authority; full includes all relationship rows."}},"additionalProperties":false},"ReadManyCall":{"type":"object","additionalProperties":false,"required":["snapshot","items"],"description":"Read 1–32 selected items from one explicit snapshot, preserving order. The complete JSON result is limited to 2 MiB; any failed item rejects the entire request.","properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"items":{"type":"array","minItems":1,"maxItems":32,"uniqueItems":true,"items":{"$ref":"#/$defs/ReadManyItem"}}}},"ReadManyResult":{"type":"object","additionalProperties":false,"required":["kind","snapshot","items"],"properties":{"kind":{"const":"read-many-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"items":{"type":"array","minItems":1,"maxItems":32,"items":{"oneOf":[{"$ref":"#/$defs/CompactReadResult"},{"$ref":"#/$defs/ReadResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/OperationalReadResult"}]}}}},"ApplicationReadManyItem":{"type":"object","additionalProperties":false,"required":["target"],"properties":{"target":{"$ref":"#/$defs/CanonicalId"},"detail":{"enum":["compact","full"]}}},"ApplicationReadManyCall":{"type":"object","additionalProperties":false,"required":["snapshot","items"],"description":"Read 1–32 selected items from one explicit snapshot, preserving order. The complete JSON result is limited to 2 MiB; any failed item rejects the entire request.","properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"items":{"type":"array","minItems":1,"maxItems":32,"uniqueItems":true,"items":{"$ref":"#/$defs/ApplicationReadManyItem"}}}},"ApplicationReadManyResult":{"type":"object","additionalProperties":false,"required":["kind","snapshot","items","purpose"],"properties":{"kind":{"const":"application-read-many-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"items":{"type":"array","minItems":1,"maxItems":32,"items":{"oneOf":[{"$ref":"#/$defs/ApplicationReadResult"}]}},"purpose":{"const":"application"}}},"RegisterConsumerEdit":{"type":"object","additionalProperties":false,"required":["kind","consumer","path","artifact_kind","authority"],"properties":{"kind":{"const":"register-consumer"},"consumer":{"$ref":"#/$defs/CanonicalId"},"path":{"$ref":"#/$defs/NonEmptyString"},"artifact_kind":{"enum":["fixture","documentation","implementation-artifact","prompt","template"]},"authority":{"enum":["evidence","projection"]}},"description":"Register an existing tracked consumer within this proposal. The Engine captures original-revision bytes; use separate policy relationships to declare consumers and review obligations."},"PreviewApplicationCall":{"type":"object","additionalProperties":false,"required":["revision","request"],"properties":{"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"request":{"$ref":"#/$defs/ApplicationQueryRequest"}},"description":"Authoring-only inspection of an exact draft as an application agent would receive it, including each item\'s review label; this observation neither publishes nor grants ordinary application access."},"CandidateApplicationNextOperation":{"type":"object","additionalProperties":false,"required":["operation","revision","request"],"properties":{"operation":{"const":"preview_application"},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"},"request":{"$ref":"#/$defs/ApplicationQueryRequest"}}},"CandidateApplicationPolicy":{"type":"object","additionalProperties":false,"required":["id","role","level"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"role":{"enum":["core","router","topic","workflow","profile","reference","prompt","template","documentation"]},"level":{"enum":["MUST","SHOULD","PROFILE","REFERENCE"]}}},"CandidateApplicationRelationship":{"type":"object","additionalProperties":false,"required":["source","target","relation","groups","direction"],"properties":{"source":{"$ref":"#/$defs/CanonicalId"},"target":{"$ref":"#/$defs/CanonicalId"},"relation":{"type":"string"},"groups":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"direction":{"enum":["incoming","outgoing"]}}},"CandidateApplicationReadResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","policy","review_state","content","scope","requires","specializes","next_operations","revision"],"properties":{"kind":{"const":"candidate-application-read-result"},"purpose":{"const":"application"},"policy":{"$ref":"#/$defs/CandidateApplicationPolicy"},"review_state":{"$ref":"#/$defs/ApplicationReviewState"},"content":{"type":"string"},"scope":{"$ref":"#/$defs/ReviewScope"},"requires":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"specializes":{"type":"array","items":{"$ref":"#/$defs/CanonicalId"}},"related":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationRelationship"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationNextOperation"}},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}}},"CandidateApplicationRelatedResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","target","relationships","next_operations","revision"],"properties":{"kind":{"const":"candidate-application-related-result"},"purpose":{"const":"application"},"target":{"$ref":"#/$defs/CanonicalId"},"relationships":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationRelationship"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationNextOperation"}},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}}},"CandidateApplicationRouteResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","status","reading_plan","unresolved_questions","next_operations","revision"],"properties":{"kind":{"const":"candidate-application-route-result"},"purpose":{"const":"application"},"status":{"enum":["complete","needs-facts"]},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ApplicationReadingEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/ApplicationQuestion"}},"next_operations":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationNextOperation"}},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}}},"CandidateApplicationRejectedResult":{"type":"object","additionalProperties":false,"required":["kind","purpose","code","outcome","message","next_operations","revision"],"properties":{"kind":{"const":"candidate-application-rejected-result"},"purpose":{"const":"application"},"code":{"enum":["APPLICATION.UNKNOWN_TARGET","APPLICATION.INPUT_INVALID","APPLICATION.OPERATION_UNAVAILABLE","APPLICATION.INTERNAL_UNAVAILABLE","APPLICATION.UNSUPPORTED_CAPTURE","APPLICATION.RESULT_LIMIT","APPLICATION.UNKNOWN_GROUP","APPLICATION.TRAVERSAL_NOT_PERMITTED"]},"outcome":{"enum":["invalid","unsupported","unavailable"]},"message":{"type":"string"},"next_operations":{"type":"array","items":{"$ref":"#/$defs/CandidateApplicationNextOperation"}},"revision":{"$ref":"#/$defs/ProposalRevisionHandle"}}},"PreviewApplicationResult":{"oneOf":[{"$ref":"#/$defs/CandidateApplicationReadResult"},{"$ref":"#/$defs/CandidateApplicationRelatedResult"},{"$ref":"#/$defs/CandidateApplicationRouteResult"},{"$ref":"#/$defs/CandidateApplicationRejectedResult"}]},"ResolveManyCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/AnalysisHandle"},"submissions":{"type":"array","items":{"$ref":"#/$defs/Submission"},"minItems":1,"maxItems":128},"detail":{"enum":["compact","full"]}},"required":["context","submissions"],"description":"Resolve ordered decisions bound to one original analysis. Validate every item before publishing a final immutable successor; an invalid batch persists no intermediate decisions."},"WorkflowSection":{"enum":["pending_obligations","obligations","fact_requirements","coverage_certificates","dispositions","fact_observations","reading_plan","changed_units"]},"WorkflowAnalysisSummary":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"workflow-analysis-summary"},"status":{"enum":["needs-action","complete"]},"required_obligations":{"type":"integer","minimum":0},"pending_facts":{"type":"integer","minimum":0},"sections":{"type":"array","items":{"$ref":"#/$defs/WorkflowSectionCount"}},"details":{"$ref":"#/$defs/WorkflowDetailsLink"}},"required":["kind","status","required_obligations","pending_facts","sections","details"],"description":"Counts for the enclosing immutable Analysis context. Observation remains summary-only; successful compact pending mutations additionally return a bounded work page."},"WorkflowSectionCount":{"type":"object","additionalProperties":false,"properties":{"section":{"$ref":"#/$defs/WorkflowSection"},"count":{"type":"integer","minimum":0}},"required":["section","count"]},"WorkflowDetailsLink":{"type":"object","additionalProperties":false,"properties":{"operation":{"const":"workflow_details"}},"required":["operation"],"description":"Supply the enclosing WorkflowResult Analysis context as analysis and explicitly select a section."},"WorkflowDetailsCall":{"type":"object","additionalProperties":false,"properties":{"analysis":{"$ref":"#/$defs/AnalysisHandle"},"section":{"$ref":"#/$defs/WorkflowSection"},"offset":{"type":"integer","minimum":0},"limit":{"type":"integer","minimum":1,"maximum":16},"observation":{"$ref":"#/$defs/Digest"},"detail":{"enum":["compact","full"],"description":"Compact is byte-bounded; full explicitly retrieves one whole record without the compact byte cap."}},"required":["analysis","section"],"description":"Read a section of an immutable historical Analysis. Compact pages (default eight items) contain up to 16 whole records and 64 KiB of result JSON, returning fewer items when needed. An oversized record returns an explicit full-detail retry. detail=full retrieves one complete record (limit omitted or 1) without the compact byte cap; choose it only when the client can receive that payload. Continuations bind the Analysis, section and projected contents. Decision and publication operations check current evidence and authorization. A full-record response resumes compact paging in its next request."},"WorkflowDetailItem":{"oneOf":[{"$ref":"#/$defs/Obligation"},{"$ref":"#/$defs/FactRequirementWork"},{"$ref":"#/$defs/CoverageCertificate"},{"$ref":"#/$defs/DispositionRecord"},{"$ref":"#/$defs/FactObservation"},{"$ref":"#/$defs/ReadingPlanEntry"},{"$ref":"#/$defs/ChangedPolicyUnit"},{"$ref":"#/$defs/WorkflowObligationWork"}]},"WorkflowDetailsResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"workflow-details-result"},"analysis":{"$ref":"#/$defs/AnalysisHandle"},"section":{"$ref":"#/$defs/WorkflowSection"},"observation":{"$ref":"#/$defs/Digest"},"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","items":{"$ref":"#/$defs/WorkflowDetailItem"},"maxItems":16},"next":{"$ref":"#/$defs/WorkflowDetailsCall"}},"required":["kind","analysis","section","observation","offset","total","items"],"description":"Whole records from an immutable Analysis section. Compact may return fewer than limit to respect 64 KiB. Full returns at most one complete record and may exceed 64 KiB. Follow next exactly; observation and total are independent of page size and detail mode."},"RuntimeInfoCall":{"type":"object","additionalProperties":false,"properties":{"expected_catalog":{"$ref":"#/$defs/Digest"}},"required":[]},"RuntimeInfoResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"runtime-info-result"},"purpose":{"enum":["application","authoring"]},"interface_version":{"type":"integer","minimum":1},"implementation_version":{"type":"string","minLength":1},"instance_id":{"type":"string","minLength":1},"implementation_digest":{"$ref":"#/$defs/Digest"},"catalog_digest":{"$ref":"#/$defs/Digest"},"schema_digest":{"$ref":"#/$defs/Digest"},"installation_state":{"enum":["current","restart-required","unavailable"]},"client_catalog_state":{"enum":["unspecified","matches","differs"]},"action":{"enum":["reuse","restart-and-reconnect","refresh-tools","check-installation"]}},"required":["kind","purpose","interface_version","implementation_version","instance_id","implementation_digest","catalog_digest","schema_digest","installation_state","client_catalog_state","action"]},"WorkflowObligationWork":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"workflow-obligation-work"},"obligation":{"$ref":"#/$defs/Obligation"},"work":{"$ref":"#/$defs/AnalysisChildHandle"}},"required":["kind","obligation","work"]},"WorkflowDetailsNextOperation":{"type":"object","additionalProperties":false,"properties":{"operation":{"const":"workflow_details"},"request_kind":{"const":"workflow-details"},"request":{"$ref":"#/$defs/WorkflowDetailsCall"}},"required":["operation","request_kind","request"],"description":"An explicit historical detail retrieval alternative. Invoke operation with request; do not automatically select size-unbounded full detail."},"WorkflowDetailsSelection":{"type":"object","additionalProperties":false,"properties":{"section":{"$ref":"#/$defs/WorkflowSection"},"offset":{"type":"integer","minimum":0},"limit":{"type":"integer","minimum":1,"maximum":16},"observation":{"$ref":"#/$defs/Digest"},"detail":{"enum":["compact","full"],"description":"Compact is byte-bounded; full explicitly retrieves one whole record without the compact byte cap."}},"required":["section"],"description":"A workflow_details selection relative to the enclosing WorkflowResult Analysis context. Add analysis from that context when invoking; preserve every returned selection field."},"WorkflowWorkPage":{"type":"object","additionalProperties":false,"description":"First actionable section of a successful compact pending mutation, bound to the enclosing Analysis context. Facts precede obligations. Up to eight whole items and 64 KiB of page JSON; next is a relative workflow_details selection. Work handles retain their complete authority.","properties":{"kind":{"const":"workflow-work-page"},"section":{"enum":["fact_requirements","pending_obligations"]},"observation":{"$ref":"#/$defs/Digest"},"offset":{"const":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","maxItems":8,"items":{"oneOf":[{"$ref":"#/$defs/FactRequirementWork"},{"$ref":"#/$defs/WorkflowObligationWork"}]}},"next":{"$ref":"#/$defs/WorkflowDetailsSelection"}},"required":["kind","section","observation","offset","total","items"]},"WorkflowWorkDeferred":{"type":"object","additionalProperties":false,"description":"The mutation succeeded but its first complete work record exceeds the compact page budget. Preserve the enclosing context and counts; request explicitly selects that exact full record without the compact byte cap.","properties":{"kind":{"const":"workflow-work-deferred"},"code":{"const":"WORKFLOW.RESULT_LIMIT"},"section":{"enum":["fact_requirements","pending_obligations"]},"total":{"type":"integer","minimum":0},"request":{"$ref":"#/$defs/WorkflowDetailsSelection"}},"required":["kind","code","section","total","request"]},"AgentAuthoredDecisionProvenance":{"type":"object","additionalProperties":false,"required":["id","subject","origin","rationale","evidence"],"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"subject":{"$ref":"#/$defs/CanonicalId"},"origin":{"enum":["documented-original","reconstructed-history","current-justification","unrecorded"]},"rationale":{"type":"string"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"}},"assumptions":{"type":"array","items":{"type":"string"}},"limits":{"type":"array","items":{"type":"string"}},"alternatives":{"type":"array","items":{"type":"string"}},"reconsideration":{"type":"array","items":{"type":"string"}},"supersedes":{"type":"array","items":{"type":"string"}}}},"AgentConsumerDispositionSubmission":{"type":"object","required":["kind","obligation","result","rationale","evidence","fingerprint"],"properties":{"kind":{"const":"consumer-disposition"},"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"result":{"enum":["updated","reviewed-no-change","not-applicable","blocked"]},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"minItems":1},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"AgentCoverageAttestationClaim":{"type":"object","required":["requirement","conclusion","evidence","explicit_exclusions","rationale","auditor_provenance"],"properties":{"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"conclusion":{"const":"complete"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"minItems":1,"uniqueItems":true},"explicit_exclusions":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"uniqueItems":true},"rationale":{"$ref":"#/$defs/NonEmptyString"},"auditor_provenance":{"$ref":"#/$defs/NonEmptyString"}},"additionalProperties":false},"AgentCoverageAttestationSubmission":{"type":"object","required":["kind","claim"],"properties":{"kind":{"const":"coverage-attestation"},"claim":{"$ref":"#/$defs/AgentCoverageAttestationClaim"}},"additionalProperties":false},"AgentImpactDispositionSubmission":{"type":"object","required":["kind","obligation","result","rationale","evidence","fingerprint"],"properties":{"kind":{"const":"impact-disposition"},"obligation":{"$ref":"#/$defs/AnalysisChildHandle"},"result":{"enum":["confirmed","resolved-no-impact","requires-change","blocked"]},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"minItems":1},"fingerprint":{"$ref":"#/$defs/DecisionFingerprint"}},"additionalProperties":false},"AgentProposeCall":{"type":"object","additionalProperties":false,"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"change_set":{"$ref":"#/$defs/AgentStandardsChangeSet"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["change_set"]},"AgentProvideFactSubmission":{"type":"object","required":["kind","requirement","value","evidence"],"properties":{"kind":{"const":"provide-fact"},"requirement":{"$ref":"#/$defs/AnalysisChildHandle"},"value":{"$ref":"#/$defs/FactValue"},"evidence":{"type":"array","items":{"$ref":"#/$defs/AgentEvidenceReference"},"minItems":1,"uniqueItems":true}},"additionalProperties":false},"AgentPutDecisionProvenanceEdit":{"type":"object","additionalProperties":false,"required":["kind","record"],"properties":{"kind":{"const":"put-provenance"},"record":{"$ref":"#/$defs/AgentAuthoredDecisionProvenance"}}},"AgentRelationshipDisposition":{"type":"object","required":["relationship","disposition","rationale","evidence"],"properties":{"relationship":{"$ref":"#/$defs/RelationshipKey"},"disposition":{"enum":["remove","retarget"]},"replacement_consumer":{"$ref":"#/$defs/RelationshipConsumer"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentResolveManyCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/AnalysisHandle"},"submissions":{"type":"array","items":{"$ref":"#/$defs/AgentSubmission"},"minItems":1,"maxItems":128},"detail":{"enum":["compact","full"]},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["context","submissions"],"description":"Resolve ordered decisions bound to one original analysis. Validate every item before publishing a final immutable successor; an invalid batch persists no intermediate decisions."},"AgentResolveWorkflowCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"submission":{"$ref":"#/$defs/AgentSubmission"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["context","submission"]},"AgentRetirePolicyUnitEdit":{"type":"object","required":["kind","policy","retired_semantic_revision","successors","relationship_dispositions","evidence"],"properties":{"kind":{"const":"retire-policy-unit"},"policy":{"$ref":"#/$defs/CanonicalId"},"retired_semantic_revision":{"type":"integer","minimum":1},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"relationship_dispositions":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/AgentRelationshipDisposition"}},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentRetireStandardEdit":{"type":"object","required":["kind","standard","successors","relationship_dispositions","evidence"],"properties":{"kind":{"const":"retire-standard"},"standard":{"$ref":"#/$defs/CanonicalId"},"successors":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/CanonicalId"}},"relationship_dispositions":{"type":"array","uniqueItems":true,"items":{"$ref":"#/$defs/AgentRelationshipDisposition"}},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentReviewCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"decisions":{"type":"array","minItems":3,"maxItems":3,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentReviewDecision"}},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["context","decisions"]},"AgentReviewDecision":{"type":"object","required":["owner","decision","rationale","evidence"],"properties":{"owner":{"enum":["consumer","impact","audit"]},"decision":{"const":"accept"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentReviseCall":{"type":"object","additionalProperties":false,"properties":{"context":{"$ref":"#/$defs/WorkflowContext"},"change_set":{"$ref":"#/$defs/AgentStandardsChangeSet"},"detail":{"enum":["compact","full"],"description":"Compact (default) returns an exact workflow summary; full returns complete analysis detail."},"evidence":{"$ref":"#/$defs/RequestEvidenceTable"}},"required":["context","change_set"]},"AgentStandardEdit":{"oneOf":[{"$ref":"#/$defs/CreateStandardEdit"},{"$ref":"#/$defs/RegisterPolicyUnitEdit"},{"$ref":"#/$defs/ReviseStandardEdit"},{"$ref":"#/$defs/RevisePolicyUnitEdit"},{"$ref":"#/$defs/MovePolicyUnitEdit"},{"$ref":"#/$defs/AgentRetirePolicyUnitEdit"},{"$ref":"#/$defs/AgentRetireStandardEdit"},{"$ref":"#/$defs/ReplaceStandardRelationshipsEdit"},{"$ref":"#/$defs/PutPolicyRelationshipEdit"},{"$ref":"#/$defs/RemovePolicyRelationshipEdit"},{"$ref":"#/$defs/PutRoutingRuleEdit"},{"$ref":"#/$defs/RemoveRoutingRuleEdit"},{"$ref":"#/$defs/PutRoutingFactEdit"},{"$ref":"#/$defs/RemoveRoutingFactEdit"},{"$ref":"#/$defs/AuditPolicyUnitEdit"},{"$ref":"#/$defs/RewriteNavigationIndexEdit"},{"$ref":"#/$defs/AgentPutDecisionProvenanceEdit"},{"$ref":"#/$defs/RetireDecisionProvenanceEdit"},{"$ref":"#/$defs/ApproveApplicationContentEdit"},{"$ref":"#/$defs/WithdrawApplicationContentEdit"},{"$ref":"#/$defs/ReviseOperationalArtifactEdit"},{"$ref":"#/$defs/RegisterConsumerEdit"}]},"AgentStandardsChangePurpose":{"type":"object","required":["summary","rationale","evidence"],"properties":{"summary":{"$ref":"#/$defs/NonEmptyString"},"rationale":{"$ref":"#/$defs/NonEmptyString"},"evidence":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentEvidenceReference"}}},"additionalProperties":false},"AgentStandardsChangeSet":{"type":"object","required":["purpose","edits"],"properties":{"purpose":{"$ref":"#/$defs/AgentStandardsChangePurpose"},"edits":{"type":"array","minItems":1,"uniqueItems":true,"items":{"$ref":"#/$defs/AgentStandardEdit"}}},"additionalProperties":false},"AgentSubmission":{"oneOf":[{"$ref":"#/$defs/AgentProvideFactSubmission"},{"$ref":"#/$defs/AgentConsumerDispositionSubmission"},{"$ref":"#/$defs/AgentImpactDispositionSubmission"},{"$ref":"#/$defs/AgentCoverageAttestationSubmission"}]},"EvidenceUse":{"type":"object","required":["evidence_ref"],"properties":{"evidence_ref":{"$ref":"#/$defs/CanonicalId"}},"additionalProperties":false,"description":"Select one exact reference from the evidence table of this request only. This is not an authorization or an attestation."},"AgentEvidenceReference":{"oneOf":[{"$ref":"#/$defs/EvidenceReference"},{"$ref":"#/$defs/EvidenceUse"}]},"RequestEvidenceTable":{"type":"object","additionalProperties":{"$ref":"#/$defs/EvidenceReference"},"description":"At most 128 request-local named exact references. Every entry must be used; each evidence_ref must name an entry. Expanded native validation and all ordinary evidence checks still apply."},"RouteContentSelection":{"type":"object","properties":{"offset":{"type":"integer","minimum":0,"description":"Default zero. A nonzero offset requires an explicit snapshot from the same route."},"limit":{"type":"integer","minimum":1,"maximum":32,"description":"Maximum whole policy reads in this page; default eight. Byte pressure may return fewer."}},"additionalProperties":false},"RoutedContentPage":{"type":"object","required":["offset","total","items"],"properties":{"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","maxItems":32,"items":{"oneOf":[{"$ref":"#/$defs/CompactReadResult"},{"$ref":"#/$defs/ReadResult"},{"$ref":"#/$defs/NavigationIndexesResult"},{"$ref":"#/$defs/ProvenanceReadResult"},{"$ref":"#/$defs/OperationalReadResult"}]}},"next":{"$ref":"#/$defs/RouteCall"}},"additionalProperties":false,"description":"Exact compact reads of selected targets in Router order. Total counts selected targets, not unresolved applicability. Follow next unchanged for the remaining page."},"ApplicationRoutedContentPage":{"type":"object","required":["offset","total","items"],"properties":{"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","maxItems":32,"items":{"$ref":"#/$defs/ApplicationReadResult"}},"next":{"$ref":"#/$defs/RouteCall"}},"additionalProperties":false,"description":"Exact compact reads of selected targets in Router order, each with its review label. Total counts selected targets, not unresolved applicability. A page ends early at the host\'s page byte budget but holds at least one whole item while targets remain. Follow next unchanged for the remaining page."},"DescribeInputCall":{"type":"object","additionalProperties":false,"properties":{"operation":{"type":"string","minLength":1,"description":"An operation published in this running catalog."},"selector":{"type":"string","pattern":"^[A-Za-z][A-Za-z0-9]*$","description":"A returned definition name (or the name in a schema $ref). Omit for the operation input root."},"expected_catalog":{"$ref":"#/$defs/Digest"},"offset":{"type":"integer","minimum":0,"description":"Record offset within the selected closure. Continue with the returned next request."},"limit":{"type":"integer","minimum":1,"maximum":16,"description":"Maximum whole schema records in this page; default 8. Byte pressure may return fewer."}},"required":["operation"]},"InputSchemaRecord":{"type":"object","additionalProperties":false,"properties":{"name":{"type":"string","minLength":1},"schema_json":{"type":"string","minLength":1,"description":"Exact JSON Schema definition serialized as a JSON document; $refs name other returned/selectable definitions. Not a standalone validator without its closure."}},"required":["name","schema_json"]},"InputContractResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"input-contract-result"},"purpose":{"enum":["application","authoring"]},"interface_version":{"type":"integer","minimum":1},"catalog_digest":{"$ref":"#/$defs/Digest"},"operation":{"type":"string","minLength":1},"root":{"type":"string","minLength":1},"selector":{"type":"string","minLength":1},"dialect":{"const":"https://json-schema.org/draft/2020-12/schema"},"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":1},"records":{"type":"array","maxItems":16,"items":{"$ref":"#/$defs/InputSchemaRecord"}},"next":{"$ref":"#/$defs/DescribeInputCall"}},"required":["kind","purpose","interface_version","catalog_digest","operation","root","selector","dialect","offset","total","records"]},"InputContractRejectedResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"input-contract-rejected-result"},"purpose":{"enum":["application","authoring"]},"code":{"enum":["INPUT_DISCOVERY.INVALID_ARGUMENTS","INPUT_DISCOVERY.OPERATION_UNAVAILABLE","INPUT_DISCOVERY.CATALOG_CHANGED","INPUT_DISCOVERY.SELECTION_INVALID","INPUT_DISCOVERY.RESULT_LIMIT"]},"outcome":{"enum":["invalid","unavailable","unsupported"]},"message":{"type":"string","minLength":1},"input_feedback":{"$ref":"#/$defs/InputFeedback"}},"required":["kind","purpose","code","outcome","message"]},"InputIssue":{"type":"object","additionalProperties":false,"properties":{"instance_pointer":{"type":"string","description":"JSON Pointer to the invalid field; non-exact locations redact dynamic keys as * or use the root."},"location_exact":{"type":"boolean"},"keyword":{"type":"string"},"message":{"type":"string"}},"required":["instance_pointer","location_exact","keyword","message"]},"InputFeedback":{"type":"object","additionalProperties":false,"properties":{"issues":{"type":"array","maxItems":8,"items":{"$ref":"#/$defs/InputIssue"}},"truncated":{"type":"boolean","description":"Additional diagnostic detail was omitted due to a work, item or byte bound."},"describe_input":{"$ref":"#/$defs/DescribeInputCall"}},"required":["issues","truncated","describe_input"]},"RelationshipGroupsCall":{"type":"object","additionalProperties":false,"properties":{"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"offset":{"type":"integer","minimum":0,"description":"Continue with the exact snapshot and offset returned by next. Nonzero offsets require a snapshot."},"limit":{"type":"integer","minimum":1,"maximum":32,"description":"Whole records per page, default 8; byte pressure may return fewer."}},"required":[]},"RelationshipGroup":{"type":"object","additionalProperties":false,"properties":{"id":{"$ref":"#/$defs/CanonicalId"},"description":{"type":"string"},"traversal_directions":{"type":"array","minItems":1,"uniqueItems":true,"items":{"enum":["incoming","outgoing"]},"description":"Directions permitted by this group for traversals; adjacency queries remain distinct."},"transitive":{"type":"boolean","description":"Whether the group permits transitive traversal."}},"required":["id","description","traversal_directions","transitive"]},"RelationshipGroupsResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"relationship-groups-result"},"purpose":{"enum":["application","authoring"]},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":0},"items":{"type":"array","maxItems":32,"items":{"$ref":"#/$defs/RelationshipGroup"}},"next":{"$ref":"#/$defs/RelationshipGroupsCall"}},"required":["kind","purpose","snapshot","offset","total","items"]},"CompactRouteResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"compact-route-result"},"snapshot":{"$ref":"#/$defs/SnapshotHandle"},"status":{"enum":["complete","needs-facts"]},"facts":{"$ref":"#/$defs/RoutingFactAssertions"},"reading_plan":{"type":"array","items":{"$ref":"#/$defs/ReadingPlanEntry"}},"unresolved_questions":{"type":"array","items":{"$ref":"#/$defs/RoutingQuestion"}},"unresolved_policy_count":{"type":"integer","minimum":0},"explanation":{"$ref":"#/$defs/RouteCall"},"next_operations":{"type":"array","items":{"$ref":"#/$defs/NextOperation"}},"summary":{"type":"string"},"content":{"$ref":"#/$defs/RoutedContentPage"}},"required":["kind","snapshot","status","facts","reading_plan","unresolved_questions","unresolved_policy_count","explanation","next_operations"]},"DescribeOutputCall":{"type":"object","additionalProperties":false,"properties":{"operation":{"type":"string","minLength":1,"description":"An operation published in this running catalog."},"selector":{"type":"string","pattern":"^[A-Za-z][A-Za-z0-9]*$","description":"A returned output definition name. Omit for the complete operation result algebra."},"expected_catalog":{"$ref":"#/$defs/Digest"},"offset":{"type":"integer","minimum":0,"description":"Record offset within the selected closure. Continue with the returned next request."},"limit":{"type":"integer","minimum":1,"maximum":16,"description":"Maximum whole schema records in this page; default 8. Byte pressure may return fewer."}},"required":["operation"]},"OutputSchemaRecord":{"type":"object","additionalProperties":false,"properties":{"name":{"type":"string","minLength":1},"schema_json":{"type":"string","minLength":1,"description":"Exact JSON Schema definition serialized as a JSON document; $refs name other returned/selectable definitions. Not a standalone validator without its closure."}},"required":["name","schema_json"]},"OutputContractResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"output-contract-result"},"purpose":{"enum":["application","authoring"]},"interface_version":{"type":"integer","minimum":1},"catalog_digest":{"$ref":"#/$defs/Digest"},"operation":{"type":"string","minLength":1},"selector":{"type":"string","minLength":1},"dialect":{"const":"https://json-schema.org/draft/2020-12/schema"},"offset":{"type":"integer","minimum":0},"total":{"type":"integer","minimum":1},"records":{"type":"array","maxItems":16,"items":{"$ref":"#/$defs/OutputSchemaRecord"}},"next":{"$ref":"#/$defs/DescribeOutputCall"},"roots":{"type":"array","minItems":1,"uniqueItems":true,"items":{"type":"string","minLength":1}},"root_schema_json":{"type":"string","minLength":1,"description":"Exact operation result schema without $defs. Combine with all result-root definition pages for validation; schema_digest binds the full schema."},"schema_digest":{"$ref":"#/$defs/Digest"}},"required":["kind","purpose","interface_version","catalog_digest","operation","dialect","offset","total","records","roots","root_schema_json","schema_digest"]},"OutputContractRejectedResult":{"type":"object","additionalProperties":false,"properties":{"kind":{"const":"output-contract-rejected-result"},"purpose":{"enum":["application","authoring"]},"code":{"enum":["OUTPUT_DISCOVERY.INVALID_ARGUMENTS","OUTPUT_DISCOVERY.OPERATION_UNAVAILABLE","OUTPUT_DISCOVERY.CATALOG_CHANGED","OUTPUT_DISCOVERY.SELECTION_INVALID","OUTPUT_DISCOVERY.RESULT_LIMIT"]},"outcome":{"enum":["invalid","unavailable","unsupported"]},"message":{"type":"string","minLength":1},"input_feedback":{"$ref":"#/$defs/InputFeedback"}},"required":["kind","purpose","code","outcome","message"]},"RoutingFactAssertion":{"oneOf":[{"type":"boolean"},{"type":"null"},{"type":"string"},{"type":"array","items":{"type":"string"},"uniqueItems":true},{"type":"object","additionalProperties":false,"required":["state"],"properties":{"state":{"enum":["known-absent","unknown"]}}}]},"RoutingFactAssertions":{"type":"object","additionalProperties":{"$ref":"#/$defs/RoutingFactAssertion"}}}}') +DEFINITION_METADATA = freeze_json({'ActiveSnapshotSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'lifecycle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'created_at': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentAuthoredDecisionProvenance': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'origin': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'assumptions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limits': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'alternatives': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reconsideration': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'supersedes': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentConsumerDispositionSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentCoverageAttestationClaim': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'conclusion': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'explicit_exclusions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'auditor_provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentCoverageAttestationSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'claim': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentEvidenceReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AgentImpactDispositionSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentProposeCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentProvideFactSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentPutDecisionProvenanceEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'record': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentRelationshipDisposition': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'disposition': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'replacement_consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentResolveManyCall': {'title': None, 'description': 'Resolve ordered decisions bound to one original analysis. Validate every item before publishing a final immutable successor; an invalid batch persists no intermediate decisions.', 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submissions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentResolveWorkflowCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submission': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentRetirePolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retired_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentRetireStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentReviewCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decisions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentReviewDecision': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentReviseCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rules': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AgentStandardsChangePurpose': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentStandardsChangeSet': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edits': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AgentSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AllExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expressions': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AlwaysExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisChildArtifact': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AnalysisChildHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'child_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'child_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisChildInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'artifact': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisContext': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subjects': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_proposals': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisExecutionContractView': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'authorization_authority_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'providers': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AnalysisInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisMaterialHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AnalysisRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'base_snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_proposals': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prior_analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'contract_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalysisState': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'base_snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_reference': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_proposals': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_observations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage_attestations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_records': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'domain_contracts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'execution_contracts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'contract_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnalyzeCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'AnalyzeProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AnyExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expressions': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicabilityExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ApplicationExposureState': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ApplicationHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ApplicationInspectCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationPolicy': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'level': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationPublicationReceipt': {'title': None, 'description': 'Durable application identity and exact candidate facts, separate from the fresh target observation.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'candidate_commit': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'candidate_tree': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target_ref': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expected_predecessor': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'durable_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target_observation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationQueryCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationQueryRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ApplicationQuestion': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadManyCall': {'title': None, 'description': 'Read 1–32 selected items from one explicit snapshot, preserving order. The complete JSON result is limited to 2 MiB; any failed item rejects the entire request.', 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadManyItem': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadManyResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'review_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'related': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReadingEntry': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'review_state': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRecoveryRequiredResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checkout': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'details': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_feedback': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_groups': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRelatedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationships': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRelationship': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationReviewState': {'title': None, 'description': 'Review label of delivered application material. current: this exact text was approved for application use. changed-since-review: the text was edited after its approval. not-reviewed: the text has never been approved. The label never withholds material; a scoped policy read carries the label of its containing module.', 'has_default': False, 'default': None, 'properties': {}}, 'ApplicationRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRoutedContentPage': {'title': None, 'description': "Exact compact reads of selected targets in Router order, each with its review label. Total counts selected targets, not unresolved applicability. A page ends early at the host's page byte budget but holds at least one whole item while targets remain. Follow next unchanged for the remaining page.", 'has_default': False, 'default': None, 'properties': {'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplicationRoutingFactsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplyCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ApplyProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApplyProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checkout': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ApproveApplicationContentEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuditPolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthoredDecisionProvenance': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'origin': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'assumptions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limits': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'alternatives': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reconsideration': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'supersedes': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthoredRoutingFact': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'type': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'nullable': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'values': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'aliases': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'meaning': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prompt': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthoredRoutingRule': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'condition': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthoringTargetHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthorizationId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'AuthorizationRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'reference': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'issuer_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'principal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'action': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revocation_authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revocation_authority_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revocation_evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'AuthorizationReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'issuer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'capability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationPolicy': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'level': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'review_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'related': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationRejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationRelatedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationships': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationRelationship': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CandidateApplicationRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CanonicalId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'CanonicalModuleDeclaration': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'level': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applies_when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'does_not_apply_when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ChangeDescriptor': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_ids': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_ids': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_module': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_module': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ChangePolicySemantics': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'intent': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ChangedPolicyUnit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'classification': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_representation_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_representation_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_structural_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_structural_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ChildId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'CompactReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application_exposure': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CompactRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_policy_count': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'explanation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CompleteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changed_units': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage_certificates': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_observations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'completion': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CompletionProof': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'required_coverage_subjects': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'certificate_subjects': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reached_consumer_obligations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'disposition_obligations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'required_fact_requirements': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observed_fact_requirements': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'non_consumer_obligations_resolved': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability_resolved': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_valid': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_valid': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ConsumerDispositionSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ConsumerReviewContract': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'permitted_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_capability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ConsumerReviewObligationReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ContainsExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageAttestation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'conclusion': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'explicit_exclusions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'auditor_provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageAttestationClaim': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'conclusion': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'explicit_exclusions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'auditor_provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageAttestationSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'claim': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageAuditAuthority': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'issuer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'principal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_id': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageCertificate': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'horizon_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_digests': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_schema_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CoverageRequirement': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_kinds': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'horizon': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'required_evidence_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'base_snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateSnapshotCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateSnapshotResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'CreateStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_units': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DecisionDependency': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'class': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'identity': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DecisionFingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'decision_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decision_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dependencies': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DecisionProvenanceRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'origin': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'assumptions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limits': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'alternatives': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reconsideration': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'supersedes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'subject_binding': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retired': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DeleteSnapshotCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DeleteSnapshotResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purge_deadline': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DescribeInputCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': 'An operation published in this running catalog.', 'has_default': False, 'default': None}, 'selector': {'title': None, 'description': 'A returned definition name (or the name in a schema $ref). Omit for the operation input root.', 'has_default': False, 'default': None}, 'expected_catalog': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': 'Record offset within the selected closure. Continue with the returned next request.', 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': 'Maximum whole schema records in this page; default 8. Byte pressure may return fewer.', 'has_default': False, 'default': None}}}, 'DescribeOutputCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': 'An operation published in this running catalog.', 'has_default': False, 'default': None}, 'selector': {'title': None, 'description': 'A returned output definition name. Omit for the complete operation result algebra.', 'has_default': False, 'default': None}, 'expected_catalog': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': 'Record offset within the selected closure. Continue with the returned next request.', 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': 'Maximum whole schema records in this page; default 8. Byte pressure may return fewer.', 'has_default': False, 'default': None}}}, 'Digest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'DispositionRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'DomainContractReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EdgeId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'EngineCertificateRetirement': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EqualsExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceCheckRetirement': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'suite': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'check': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceConsumerRegistration': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'path': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'artifact_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_policies': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceMaintenancePlan': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'retire_engine_certificates': {'title': None, 'description': 'Explicitly retire exact registered Engine-issued certificates by subject and requirement; preserve normative policy and consumer registrations.', 'has_default': False, 'default': None}, 'prune_stale_certificates': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retire_suites': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retire_checks': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retire_inputs': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'suite_descriptions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'replacement_evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'replacement_evidence_rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_updates': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer_registrations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unregister_policy_subjects': {'title': None, 'description': 'Remove selected review-subject registrations and their source relationships while preserving normative Markdown.', 'has_default': False, 'default': None}}}, 'EvidenceReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provider_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provider_contract_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceRelationshipUpdate': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'source_policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceSuiteDescription': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'suite': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'description': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'EvidenceUse': {'title': None, 'description': 'Select one exact reference from the evidence table of this request only. This is not an authorization or an attestation.', 'has_default': False, 'default': None, 'properties': {'evidence_ref': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ExistsExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FactObservation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provider': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FactRequirement': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_contract_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'answer_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authorization_capability': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FactRequirementId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'FactRequirementWork': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prompt': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dependent_programs': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FactSet': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'FactValue': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'FactValueContract': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'type': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'states': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'nullable': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'values': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FindProposalsCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'after': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': None, 'has_default': True, 'default': 50}}}, 'FindProposalsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposals': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'continuation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FindSnapshotsCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'lifecycle': {'title': None, 'description': None, 'has_default': True, 'default': 'active'}, 'after': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': None, 'has_default': True, 'default': 50}}}, 'FindSnapshotsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshots': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'continuation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'FocusedQueryNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'GeneralSelectionReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edge': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'question': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'GitObjectId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ImpactDispositionSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'result': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ImpactTraceId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ImpactTraceReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'graph': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'values': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputContractRejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_feedback': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputContractResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'interface_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'catalog_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'root': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'selector': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dialect': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'records': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputFeedback': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'issues': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'truncated': {'title': None, 'description': 'Additional diagnostic detail was omitted due to a work, item or byte bound.', 'has_default': False, 'default': None}, 'describe_input': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputIssue': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'instance_pointer': {'title': None, 'description': 'JSON Pointer to the invalid field; non-exact locations redact dynamic keys as * or use the root.', 'has_default': False, 'default': None}, 'location_exact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'keyword': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InputSchemaRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'name': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_json': {'title': None, 'description': 'Exact JSON Schema definition serialized as a JSON document; $refs name other returned/selectable definitions. Not a standalone validator without its closure.', 'has_default': False, 'default': None}}}, 'InspectCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InspectNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'InspectableHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'InspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'MaintainEvidenceCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expected_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'apply': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'MaintainEvidenceResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applied': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changed_files': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'removed_files': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ModuleRelationshipKey': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'MovePolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'after_policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NavigationIndexEntry': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'entrypoint': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'destinations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NavigationIndexesResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'indexes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NavigationRetarget': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'entrypoint': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NewPolicyUnit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'heading_chain': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'intent': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'aliases': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'predecessors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'NextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'NonEmptyString': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'NotExpression': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operator': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expression': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'Obligation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reasons': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'permitted_submissions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'review_contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fingerprint': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ObligationId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'OperationalReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'canonical_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application_exposure': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'OutputContractRejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_feedback': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'OutputContractResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'interface_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'catalog_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'selector': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'dialect': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'records': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'roots': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'root_schema_json': {'title': None, 'description': 'Exact operation result schema without $defs. Combine with all result-root definition pages for validation; schema_digest binds the full schema.', 'has_default': False, 'default': None}, 'schema_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'OutputSchemaRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'name': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_json': {'title': None, 'description': 'Exact JSON Schema definition serialized as a JSON document; $refs name other returned/selectable definitions. Not a standalone validator without its closure.', 'has_default': False, 'default': None}}}, 'PendingResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'changed_units': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact_requirements': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyCoverageStatus': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'subject': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyImpactSelectionReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edge': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'traces': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'declaration': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'representation_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'structural_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyRelationship': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'source_policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer_scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyRelationshipInspection': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'relationship_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer_scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'propagation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence_owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyRelationshipKey': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyScopeUpdate': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'heading_path': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicySemanticIntent': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'PolicySummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyUnitDeclaration': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'module': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'heading_path': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'lifecycle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'aliases': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'predecessors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PolicyUnitMapping': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reason': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_units': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PrepareCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PreservePolicySemantics': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'intent': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PreviewApplicationCall': {'title': None, 'description': "Authoring-only inspection of an exact draft as an application agent would receive it, including each item's review label; this observation neither publishes nor grants ordinary application access.", 'has_default': False, 'default': None, 'properties': {'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PreviewApplicationResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ProposalHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ProposalPolicySummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'related': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application_exposure': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalRelatedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authoring_target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_unit_mapping': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationships': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalRelationshipSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'traversal_eligible': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalRevisionHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalRevisionId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ProposalRouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposalSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'proposal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'head_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProposeCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ProvenanceReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'record': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProvenanceRecord': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'path': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProvideFactSubmission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requirement': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'value': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ProviderReference': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'contract': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'contract_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PublicationCheckoutObservation': {'title': None, 'description': 'Fresh read-only observation of one selected checkout. Unavailable observations use null for every fact that could not be established.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'worktree_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'symbolic_branch': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'head': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'index_observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication_path_count': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'index_paths': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'worktree_paths': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PublicationPathCounts': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'predecessor': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'candidate': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'conflicted': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PublicationTargetObservation': {'title': None, 'description': 'Fresh bounded observation of the configured target ref; an unavailable revision is null.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PutDecisionProvenanceEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'record': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PutPolicyRelationshipEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PutRoutingFactEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'PutRoutingRuleEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rule': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QuarantinedSnapshotSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'lifecycle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'created_at': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purge_deadline': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryProposalNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'QueryProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'QueryRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'QueryResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'Question': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prompt': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'permitted_answers': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_coverage': {'title': None, 'description': 'Include current repository attestation status for registered policy units in this read scope.', 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact preserves exact policy and essential authority; full includes all relationship rows.', 'has_default': False, 'default': None}}}, 'ReadCoverage': {'title': None, 'description': 'Repository attestation status bound to this snapshot or proposal. Empty subjects means no registered policy units in scope, not complete coverage. Analysis-local attestations are not repository certificates.', 'has_default': False, 'default': None, 'properties': {'subjects': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadManyCall': {'title': None, 'description': 'Read 1–32 selected items from one explicit snapshot, preserving order. The complete JSON result is limited to 2 MiB; any failed item rejects the entire request.', 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadManyItem': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_coverage': {'title': None, 'description': 'Include current repository attestation status for registered policy units in this read scope.', 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact preserves exact policy and essential authority; full includes all relationship rows.', 'has_default': False, 'default': None}}}, 'ReadManyResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'include_coverage': {'title': None, 'description': 'Include current repository attestation status for registered policy units in this read scope.', 'has_default': False, 'default': None}}}, 'ReadResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'related': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'routing': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'coverage': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application_exposure': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadinessHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadinessId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ReadingPlanEntry': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reasons': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReadingPlanReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RecoverApplicationCall': {'title': None, 'description': 'Recover an admitted application. Observation performs no Git writes. Explicit completion reconstructs and verifies the exact admitted candidate before one compare-and-swap attempt.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'action': {'title': None, 'description': 'Omit or select observe to reconcile only. Explicit complete-publication revalidates and attempts the same admitted candidate against its original expected target; it requires current publication authorization.', 'has_default': False, 'default': None}}}, 'RecoverApplicationResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'application': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checkout': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RecoverCall': {'title': None, 'description': 'Recover an admitted application. Observation performs no Git writes. Explicit completion reconstructs and verifies the exact admitted candidate before one compare-and-swap attempt.', 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'action': {'title': None, 'description': 'Omit or select observe to reconcile only. Explicit complete-publication revalidates and attempts the same admitted candidate against its original expected target; it requires current publication authorization.', 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'RegisterConsumerEdit': {'title': None, 'description': 'Register an existing tracked consumer within this proposal. The Engine captures original-revision bytes; use separate policy relationships to declare consumers and review obligations.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'path': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'artifact_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authority': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RegisterPolicyUnitEdit': {'title': None, 'description': 'Register an explicitly selected policy scope in an existing standard. The Engine owns declaration placement and validates the final candidate.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_unit': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RejectedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'details': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'input_feedback': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_groups': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelatedCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'transitive': {'title': None, 'description': None, 'has_default': True, 'default': False}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelatedRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'transitive': {'title': None, 'description': None, 'has_default': True, 'default': False}}}, 'RelatedResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'authoring_target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_unit_mapping': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationships': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelationshipConsumer': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RelationshipDisposition': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'disposition': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'replacement_consumer': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelationshipGroup': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'description': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'traversal_directions': {'title': None, 'description': 'Directions permitted by this group for traversals; adjacency queries remain distinct.', 'has_default': False, 'default': None}, 'transitive': {'title': None, 'description': 'Whether the group permits transitive traversal.', 'has_default': False, 'default': None}}}, 'RelationshipGroupsCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': 'Continue with the exact snapshot and offset returned by next. Nonzero offsets require a snapshot.', 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': 'Whole records per page, default 8; byte pressure may return fewer.', 'has_default': False, 'default': None}}}, 'RelationshipGroupsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelationshipInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy_semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'provenance': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RelationshipKey': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RelationshipSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'handle': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'groups': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'direction': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'traversal_eligible': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applicability': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RemovePolicyRelationshipEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RemoveRoutingFactEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RemoveRoutingRuleEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rule': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReplaceStandardRelationshipsEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'requires': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'specializes': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RepositoryPath': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RequestEvidenceTable': {'title': None, 'description': 'At most 128 request-local named exact references. Every entry must be used; each evidence_ref must name an entry. Expanded native validation and all ordinary evidence checks still apply.', 'has_default': False, 'default': None, 'properties': {}}, 'RequiresReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edge': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ResolveCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submission': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ResolveManyCall': {'title': None, 'description': 'Resolve ordered decisions bound to one original analysis. Validate every item before publishing a final immutable successor; an invalid batch persists no intermediate decisions.', 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submissions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ResolveNextOperation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'work': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ResolveWorkflowCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'submission': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ResumeCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'RetireDecisionProvenanceEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RetirePolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retired_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RetireStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'successors': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'relationship_dispositions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviewCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decisions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ReviewDecision': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'owner': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviewProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'decisions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prior_readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviewProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviewScope': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'ReviseCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'ReviseOperationalArtifactEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'title': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'body': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RevisePolicyUnitEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'title': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'body': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'semantics': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviseProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'expected_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'change_set': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviseProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ReviseStandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'standard': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'scope_updates': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RewriteNavigationIndexEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'entrypoint': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'destinations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'retargets': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RouteCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'content': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact authoring selection is default. Full returns the rule explanation. Application always retains its qualified projection.', 'has_default': False, 'default': None}}}, 'RouteContentSelection': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'offset': {'title': None, 'description': 'Default zero. A nonzero offset requires an explicit snapshot from the same route.', 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': 'Maximum whole policy reads in this page; default eight. Byte pressure may return fewer.', 'has_default': False, 'default': None}}}, 'RouteRequest': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RouteResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'reading_plan': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'unresolved_questions': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutedContentPage': {'title': None, 'description': 'Exact compact reads of selected targets in Router order. Total counts selected targets, not unresolved applicability. Follow next unchanged for the remaining page.', 'has_default': False, 'default': None, 'properties': {'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingBaseReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'projection': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingConfiguration': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rules': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingFactAssertion': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RoutingFactAssertions': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'RoutingFactsCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingFactsResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingQuestion': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'prompt': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'fact': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingRuleExplanation': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'state': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RoutingRuleReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rule': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'facts': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RuntimeInfoCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'expected_catalog': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'RuntimeInfoResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'interface_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'implementation_version': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'instance_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'implementation_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'catalog_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'installation_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'client_catalog_state': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'action': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'ScalarValue': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'SelectionReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'SemanticProposal': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'policy': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'accepted_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposed_semantic_revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'intent': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'structural_digest': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'SnapshotChildHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'child_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'child_id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'SnapshotHandle': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'schema_version': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'SnapshotId': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'SnapshotInspectionResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'SnapshotSummary': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'SpecializesReadingReason': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edge': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'source': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'StandardContent': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'id': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'title': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'role': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'level': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'applies_when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'does_not_apply_when': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'body': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'StandardEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'StandardsChangePurpose': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'summary': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'rationale': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'evidence': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'StandardsChangeSet': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'purpose': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'edits': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'StructuredScope': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'heading_path': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'Submission': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'Timestamp': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'UndeleteSnapshotCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'UndeleteSnapshotResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'snapshot': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerificationFailure': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'message': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'suite': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'check': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerificationReport': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'passed': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'exit_code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'suites': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checks': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'failures': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerifyProposalCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerifyProposalResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'readiness': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerifyRepositoryCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'refresh_verification_inputs': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'VerifyRepositoryResult': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'refreshed_verification_inputs': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'verification': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WholeArtifactScope': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WithdrawApplicationContentEdit': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'target': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowAnalysisSummary': {'title': None, 'description': 'Counts for the enclosing immutable Analysis context. Observation remains summary-only; successful compact pending mutations additionally return a bounded work page.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'required_obligations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'pending_facts': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'sections': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'details': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowContext': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'WorkflowContinuation': {'title': None, 'description': 'Select the named operation with the enclosing WorkflowResult context and explicit required inputs. This descriptor is not an authorization grant.', 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'required_inputs': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowDetailItem': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'WorkflowDetailsCall': {'title': None, 'description': 'Read a section of an immutable historical Analysis. Compact pages (default eight items) contain up to 16 whole records and 64 KiB of result JSON, returning fewer items when needed. An oversized record returns an explicit full-detail retry. detail=full retrieves one complete record (limit omitted or 1) without the compact byte cap; choose it only when the client can receive that payload. Continuations bind the Analysis, section and projected contents. Decision and publication operations check current evidence and authorization. A full-record response resumes compact paging in its next request.', 'has_default': False, 'default': None, 'properties': {'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact is byte-bounded; full explicitly retrieves one whole record without the compact byte cap.', 'has_default': False, 'default': None}}}, 'WorkflowDetailsLink': {'title': None, 'description': 'Supply the enclosing WorkflowResult Analysis context as analysis and explicitly select a section.', 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowDetailsNextOperation': {'title': None, 'description': 'An explicit historical detail retrieval alternative. Invoke operation with request; do not automatically select size-unbounded full detail.', 'has_default': False, 'default': None, 'properties': {'operation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request_kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowDetailsResult': {'title': None, 'description': 'Whole records from an immutable Analysis section. Compact may return fewer than limit to respect 64 KiB. Full returns at most one complete record and may exceed 64 KiB. Follow next exactly; observation and total are independent of page size and detail mode.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'analysis': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowDetailsSelection': {'title': None, 'description': 'A workflow_details selection relative to the enclosing WorkflowResult Analysis context. Add analysis from that context when invoking; preserve every returned selection field.', 'has_default': False, 'default': None, 'properties': {'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'limit': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact is byte-bounded; full explicitly retrieves one whole record without the compact byte cap.', 'has_default': False, 'default': None}}}, 'WorkflowObligationWork': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'obligation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'work': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowOutcome': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'WorkflowResult': {'title': None, 'description': 'Exact immutable workflow context and relative action descriptors. Successful compact pending propose, revise, analyze and decision submissions include work from the already-produced Analysis. Status observations, full results, stale contexts and other outcomes omit work.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'proposal': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'revision': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'publication': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'checkout': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'status': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next_operations': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'outcome': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'work': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowSection': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {}}, 'WorkflowSectionCount': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'count': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowStatusCall': {'title': None, 'description': None, 'has_default': False, 'default': None, 'properties': {'context': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'detail': {'title': None, 'description': 'Compact (default) returns an exact workflow summary; full returns complete analysis detail.', 'has_default': False, 'default': None}}}, 'WorkflowWorkDeferred': {'title': None, 'description': 'The mutation succeeded but its first complete work record exceeds the compact page budget. Preserve the enclosing context and counts; request explicitly selects that exact full record without the compact byte cap.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'code': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'request': {'title': None, 'description': None, 'has_default': False, 'default': None}}}, 'WorkflowWorkPage': {'title': None, 'description': 'First actionable section of a successful compact pending mutation, bound to the enclosing Analysis context. Facts precede obligations. Up to eight whole items and 64 KiB of page JSON; next is a relative workflow_details selection. Work handles retain their complete authority.', 'has_default': False, 'default': None, 'properties': {'kind': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'section': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'observation': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'offset': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'total': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'items': {'title': None, 'description': None, 'has_default': False, 'default': None}, 'next': {'title': None, 'description': None, 'has_default': False, 'default': None}}}}) @dataclass(frozen=True, slots=True) class ActiveSnapshotSummary: @@ -1284,6 +1284,7 @@ class ApplicationReadResult: 'purpose': 'purpose', 'snapshot': 'snapshot', 'policy': 'policy', + 'review_state': 'review_state', 'content': 'content', 'scope': 'scope', 'requires': 'requires', @@ -1295,6 +1296,7 @@ class ApplicationReadResult: purpose: Literal['application'] snapshot: SnapshotHandle policy: ApplicationPolicy + review_state: ApplicationReviewState content: str scope: ReviewScope requires: tuple[CanonicalId, ...] @@ -1324,11 +1326,13 @@ class ApplicationReadingEntry: 'scope': 'scope', 'authority': 'authority', 'state': 'state', + 'review_state': 'review_state', }) target: CanonicalId scope: ReviewScope authority: Literal['normative', 'contextual'] state: Literal['selected'] + review_state: ApplicationReviewState def __post_init__(self) -> None: _RUNTIME.normalize_model(self) @@ -1397,7 +1401,7 @@ class ApplicationRejectedResult: }) kind: Literal['application-rejected-result'] purpose: Literal['application'] - code: Literal['APPLICATION.CONTENT_UNAVAILABLE', 'APPLICATION.INPUT_INVALID', 'APPLICATION.OPERATION_UNAVAILABLE', 'APPLICATION.INTERNAL_UNAVAILABLE', 'APPLICATION.UNSUPPORTED_CAPTURE', 'APPLICATION.RESULT_LIMIT', 'APPLICATION.UNKNOWN_GROUP'] + code: Literal['APPLICATION.UNKNOWN_TARGET', 'APPLICATION.INPUT_INVALID', 'APPLICATION.OPERATION_UNAVAILABLE', 'APPLICATION.INTERNAL_UNAVAILABLE', 'APPLICATION.UNSUPPORTED_CAPTURE', 'APPLICATION.RESULT_LIMIT', 'APPLICATION.UNKNOWN_GROUP', 'APPLICATION.TRAVERSAL_NOT_PERMITTED'] outcome: Literal['invalid', 'unsupported', 'unavailable'] message: str next_operations: tuple[ApplicationNextOperation, ...] @@ -1519,7 +1523,7 @@ def as_contract(self) -> dict[str, object]: @dataclass(frozen=True, slots=True) class ApplicationRoutedContentPage: - 'Exact compact reads of selected targets in Router order. Total counts selected targets, not unresolved applicability. Follow next unchanged for the remaining page.' + "Exact compact reads of selected targets in Router order, each with its review label. Total counts selected targets, not unresolved applicability. A page ends early at the host's page byte budget but holds at least one whole item while targets remain. Follow next unchanged for the remaining page." __definition__: ClassVar[str] = 'ApplicationRoutedContentPage' __contract_fields__: ClassVar = MappingProxyType({ 'offset': 'offset', @@ -1963,6 +1967,7 @@ class CandidateApplicationReadResult: 'kind': 'kind', 'purpose': 'purpose', 'policy': 'policy', + 'review_state': 'review_state', 'content': 'content', 'scope': 'scope', 'requires': 'requires', @@ -1974,6 +1979,7 @@ class CandidateApplicationReadResult: kind: Literal['candidate-application-read-result'] purpose: Literal['application'] policy: CandidateApplicationPolicy + review_state: ApplicationReviewState content: str scope: ReviewScope requires: tuple[CanonicalId, ...] @@ -2010,7 +2016,7 @@ class CandidateApplicationRejectedResult: }) kind: Literal['candidate-application-rejected-result'] purpose: Literal['application'] - code: Literal['APPLICATION.CONTENT_UNAVAILABLE', 'APPLICATION.INPUT_INVALID', 'APPLICATION.OPERATION_UNAVAILABLE', 'APPLICATION.INTERNAL_UNAVAILABLE', 'APPLICATION.UNSUPPORTED_CAPTURE', 'APPLICATION.RESULT_LIMIT'] + code: Literal['APPLICATION.UNKNOWN_TARGET', 'APPLICATION.INPUT_INVALID', 'APPLICATION.OPERATION_UNAVAILABLE', 'APPLICATION.INTERNAL_UNAVAILABLE', 'APPLICATION.UNSUPPORTED_CAPTURE', 'APPLICATION.RESULT_LIMIT', 'APPLICATION.UNKNOWN_GROUP', 'APPLICATION.TRAVERSAL_NOT_PERMITTED'] outcome: Literal['invalid', 'unsupported', 'unavailable'] message: str next_operations: tuple[CandidateApplicationNextOperation, ...] @@ -4833,7 +4839,7 @@ def as_contract(self) -> dict[str, object]: @dataclass(frozen=True, slots=True) class PreviewApplicationCall: - 'Authoring-only inspection of an exact draft through application qualification and filtering; this observation neither publishes nor grants ordinary application access.' + "Authoring-only inspection of an exact draft as an application agent would receive it, including each item's review label; this observation neither publishes nor grants ordinary application access." __definition__: ClassVar[str] = 'PreviewApplicationCall' __contract_fields__: ClassVar = MappingProxyType({ 'revision': 'revision', @@ -8231,6 +8237,7 @@ def as_contract(self) -> dict[str, object]: ApplicationExposureState: TypeAlias = Literal['unreviewed', 'current', 'needs-review'] ApplicationId: TypeAlias = str ApplicationQueryRequest: TypeAlias = RouteRequest | ApplicationReadRequest | RelatedRequest +ApplicationReviewState: TypeAlias = Literal['current', 'changed-since-review', 'not-reviewed'] AuthorizationId: TypeAlias = str CanonicalId: TypeAlias = str ChildId: TypeAlias = str @@ -8625,6 +8632,7 @@ def decode_contract(definition: str, value: object) -> object: 'ApplicationRejectedResult', 'ApplicationRelatedResult', 'ApplicationRelationship', + 'ApplicationReviewState', 'ApplicationRouteResult', 'ApplicationRoutedContentPage', 'ApplicationRoutingFactsResult', diff --git a/tools/standards_engine/standards_engine/agent_navigation.py b/tools/standards_engine/standards_engine/agent_navigation.py index c494c338..01dfb41a 100644 --- a/tools/standards_engine/standards_engine/agent_navigation.py +++ b/tools/standards_engine/standards_engine/agent_navigation.py @@ -16,6 +16,22 @@ # A composed route response includes its reading plan, questions and continuation. ROUTE_CONTENT_RESULT_BYTES = 2 * 1024 * 1024 ROUTE_CONTENT_DEFAULT_ITEMS = 8 +# Application route pages are sized for a client that shows a bounded tool +# result inline. The budget counts one serialization of the structured result. +ROUTE_PAGE_BYTES = 40 * 1024 +ROUTE_PAGE_MIN_BYTES = 8 * 1024 + + +def admit_route_page_bytes(value: int | None = None) -> int: + """Admit the host's application page budget; None selects the default.""" + if value is None: + return ROUTE_PAGE_BYTES + if type(value) is not int or not ROUTE_PAGE_MIN_BYTES <= value <= ROUTE_CONTENT_RESULT_BYTES: + raise ValueError( + f"The route page budget is a whole number of bytes from {ROUTE_PAGE_MIN_BYTES} " + f"to {ROUTE_CONTENT_RESULT_BYTES}." + ) + return value def focused_continuations(value): @@ -205,8 +221,11 @@ def with_route_content(engine, call, snapshot, compiled, routed, *, bound_facts, """Compose a bounded selected read page without another capture or compile. Results remain private through the final lifecycle check. Byte pressure ends - a page before a whole record; a single oversized record returns a typed limit - rejection so the caller can explicitly route without content and read it. + a page before a whole record. An application page uses the host's page budget + and keeps its first whole record even when that record alone exceeds the + budget, so following content.next always makes progress. Authoring keeps the + transport bound: a single oversized record returns a typed limit rejection so + the caller can explicitly route without content and read it. """ arguments = call.as_contract() if "content" not in arguments: @@ -245,8 +264,11 @@ def continuation(): if not (hint["operation"] == "read" and hint.get("target") in covered) ] - def too_large(): - return len(json.dumps(value).encode("utf-8")) > ROUTE_CONTENT_RESULT_BYTES + application = application_view is not None + budget = engine.route_page_bytes if application else ROUTE_CONTENT_RESULT_BYTES + + def exceeds(limit_bytes): + return len(json.dumps(value).encode("utf-8")) > limit_bytes for target in targets[offset:offset + limit]: engine._snapshots.snapshot(snapshot_id) @@ -256,7 +278,9 @@ def too_large(): return result page["items"].append(result.as_contract()) continuation() - if too_large(): + if exceeds(budget): + if application and len(page["items"]) == 1: + break page["items"].pop() if not page["items"]: return _route_content_rejection( @@ -265,7 +289,7 @@ def too_large(): ) break continuation() - if too_large(): + if exceeds(ROUTE_CONTENT_RESULT_BYTES): return _route_content_rejection(engine, "ROUTE.CONTENT_LIMIT", "unsupported", "Route without content to inspect this selection.") engine._snapshots.snapshot(snapshot_id) diff --git a/tools/standards_engine/standards_engine/context_projection.py b/tools/standards_engine/standards_engine/context_projection.py index a26f8ecd..cc92abc7 100644 --- a/tools/standards_engine/standards_engine/context_projection.py +++ b/tools/standards_engine/standards_engine/context_projection.py @@ -7,7 +7,10 @@ from pathlib import Path from typing import Callable, TYPE_CHECKING -from tools.graph_engine.graph_engine import Direction, EdgeRegistry, GraphContribution, GraphError +from tools.graph_engine.graph_engine import ( + Direction, EdgeRegistry, ForbiddenTraversalError, GraphContribution, GraphError, + UnknownEdgeError, UnknownGroupError, UnknownNodeError, +) from tools.standards_graph.standards_graph import Provider from tools.standards_contracts.standards_contracts import ContractError @@ -35,10 +38,15 @@ class Purpose(str, Enum): } -def application_rejection(code: str = "APPLICATION.CONTENT_UNAVAILABLE", outcome: str = "unavailable"): +# Approval is a label on delivered material, never a condition of delivery. +REVIEW_STATES = {"current": "current", "needs-review": "changed-since-review", "unreviewed": "not-reviewed"} + + +def application_rejection(code: str = "APPLICATION.INTERNAL_UNAVAILABLE", outcome: str = "unavailable"): messages = { - "APPLICATION.CONTENT_UNAVAILABLE": "The requested guidance is awaiting application publication.", + "APPLICATION.UNKNOWN_TARGET": "That identity is not registered. Use an ID or handle exactly as returned by route, read or related; nothing was inferred.", "APPLICATION.UNKNOWN_GROUP": "Choose a permitted group from relationship_groups; no group was inferred.", + "APPLICATION.TRAVERSAL_NOT_PERMITTED": "That relationship group does not permit the requested direction or transitive traversal; relationship_groups lists what each group permits.", "APPLICATION.RESULT_LIMIT": "Select fewer items or narrower policy scopes within the 2 MiB reading limit.", "APPLICATION.INPUT_INVALID": "Supply arguments from this interface's published contract.", "APPLICATION.OPERATION_UNAVAILABLE": "This interface provides application navigation operations.", @@ -67,12 +75,27 @@ def invoke(engine, call): return invoke -class _UnqualifiedContent(Exception): +class _UnknownTarget(Exception): pass +def _lookup_rejection(error: Exception): + """Name what the caller can correct; any other graph failure is internal.""" + if isinstance(error, (_UnknownTarget, UnknownEdgeError, UnknownNodeError)): + return application_rejection("APPLICATION.UNKNOWN_TARGET", "invalid") + if isinstance(error, UnknownGroupError): + return application_rejection("APPLICATION.UNKNOWN_GROUP", "invalid") + if isinstance(error, ForbiddenTraversalError): + return application_rejection("APPLICATION.TRAVERSAL_NOT_PERMITTED", "invalid") + return application_rejection("APPLICATION.INTERNAL_UNAVAILABLE") + + class ApplicationView: - """Build application values from the qualified portion of one snapshot.""" + """Build application values from the registered material of one snapshot. + + Every registered standard and operational aid is delivered with its review + label. Authoring-only provenance and unregistered consumers stay outside. + """ def __init__(self, compiled: CompiledSnapshot, authority: c.SnapshotHandle | c.ProposalRevisionHandle): @@ -80,12 +103,12 @@ def __init__(self, compiled: CompiledSnapshot, self.authority = authority.as_contract() self.candidate = isinstance(authority, c.ProposalRevisionHandle) self.snapshot = None if self.candidate else self.authority - self.eligible = frozenset( - identity for identity, material in compiled.materials.items() - if compiled.supporting.exposure_state(identity, material.binding) == "current" - ) - visible = set(self.eligible) - visible.update(unit.id for unit in compiled.corpus.policy_units if unit.module in self.eligible) + self.review = { + identity: REVIEW_STATES[compiled.supporting.exposure_state(identity, material.binding)] + for identity, material in compiled.materials.items() + } + visible = set(self.review) + visible.update(unit.id for unit in compiled.corpus.policy_units if unit.module in self.review) groups = {key: value for key, value in compiled.graph.groups.items() if key in { "standards-requires", "standards-specializes", "standards-dependencies", "policy-impact", "semantic", }} @@ -102,24 +125,13 @@ def __init__(self, compiled: CompiledSnapshot, sources = tuple(Provider(identity, GraphContribution(*(tuple(rows) for rows in records))) for identity, records in sorted(by_source.items())) self.graph = EdgeRegistry(Path("/"), sources, - logical_artifacts=(compiled.materials[key].path for key in self.eligible)) + logical_artifacts=(material.path for material in compiled.materials.values())) - def _require(self, target: str): + def _resolve(self, target: str): selected = resolve_material(self.compiled, target) if selected is None: - raise _UnqualifiedContent() - material, unit = selected - pending, checked = [material.id], set() - while pending: - identity = pending.pop() - if identity in checked: - continue - if identity not in self.eligible: - raise _UnqualifiedContent() - checked.add(identity) - owner = self.compiled.materials[identity] - pending.extend((*owner.requires, *owner.specializes)) - return material, unit + raise _UnknownTarget() + return selected def _child(self, kind: str, identity: str) -> dict: return {"kind": "snapshot-child-handle", "snapshot": self.snapshot, @@ -148,13 +160,15 @@ def _decode(self, value: dict): return types[value["kind"]].from_value(value) def read(self, target: str, detail: str = "compact"): - material, unit = self._require(target) + material, unit = self._resolve(target) identity = unit.id if unit is not None else material.id value = self._result( "application-read-result", policy={"id": identity, **({} if self.candidate else {"handle": self._child("policy", identity)}), "role": material.role, "level": material.level}, + # A scoped policy read carries the label of its containing module. + review_state=self.review[material.id], content=unit.content if unit is not None else material.content, scope={"kind": "structured", "heading_path": list(unit.heading_path)} if unit else {"kind": "whole-artifact"}, requires=list(material.requires), specializes=list(material.specializes), @@ -192,7 +206,7 @@ def relationships(self, target: str, groups, direction: Direction, transitive: b return [selected[key] for key in sorted(selected)] def related(self, target: str, groups: tuple[str, ...], direction: str, transitive: bool): - material, unit = self._require(target) + material, unit = self._resolve(target) identity = unit.id if unit else material.id relationships = self.relationships(identity, groups, Direction.parse(direction), transitive) neighbors = sorted({entry[key] for entry in relationships for key in ("source", "target")} - set(self._scope_targets(identity))) @@ -206,10 +220,8 @@ def inspect(self, handle): return self.read(handle.child_id, "full") way, _, edge_id = handle.child_id.partition(":") if way not in {"incoming", "outgoing"}: - raise _UnqualifiedContent() + raise _UnknownTarget() edge = self.graph.edge(edge_id) - self._require(edge.source) - self._require(edge.target) target = edge.target if way == "incoming" else edge.source relationships = [entry for entry in self.relationships(target, tuple(edge.groups), Direction.parse(way), False) if entry["handle"]["child_id"] == handle.child_id] @@ -219,26 +231,25 @@ def inspect(self, handle): )) def routing_facts(self): - self._require("router") return c.ApplicationRoutingFactsResult.from_value(self._result( "application-routing-facts-result", facts=self.compiled.router.fact_definitions(), next_operations=[], )) def route(self, engine, call): - self._require("router") facts = self.compiled.router.fact_schema.bind(call.as_contract()["facts"]) return self._route_bound(engine, facts) def _route_bound(self, engine, facts): - """Render a route whose Router qualification and fact binding already passed.""" + """Render every selected entry of an already bound route with its review label.""" _facts, _rules, _ordered, entries, unresolved = engine._bound_routing_selection(self.compiled, facts) reading = [] for entry in entries: if entry.state != "selected": continue - self._require(entry.target) + material, _unit = self._resolve(entry.target) reading.append({"target": entry.target, "scope": entry.scope.as_contract(), - "authority": entry.authority, "state": "selected"}) + "authority": entry.authority, "state": "selected", + "review_state": self.review[material.id]}) facts = {fact["id"]: fact for fact in self.compiled.router.fact_definitions()} return self._decode(self._result( "application-route-result", status="needs-facts" if unresolved else "complete", @@ -249,7 +260,7 @@ def _route_bound(self, engine, facts): def preview_application(engine: StandardsEngine, compiled: CompiledSnapshot, call: c.PreviewApplicationCall): - """Use application eligibility and field selection at an exact draft revision.""" + """Use application delivery, labels and field selection at an exact draft revision.""" view = ApplicationView(compiled, call.revision) request = call.request.as_contract() try: @@ -259,12 +270,10 @@ def preview_application(engine: StandardsEngine, compiled: CompiledSnapshot, return view.related(request["target"], tuple(request["groups"]), request["direction"], request["transitive"]) return view.route(engine, call.request) - except (_UnqualifiedContent, GraphError): - result = application_rejection().as_contract() + except (_UnknownTarget, GraphError) as error: return c.CandidateApplicationRejectedResult.from_value({ - **result, "kind": "candidate-application-rejected-result", + **_lookup_rejection(error).as_contract(), "kind": "candidate-application-rejected-result", "revision": call.revision.as_contract(), - "message": "Inspect the candidate's exposure and prerequisite states through authoring reads, then preview its qualified application content.", }) @@ -313,11 +322,9 @@ def application_dispatch(engine: StandardsEngine, operation: str, call): return view.read(values["target"], values.get("detail", "compact")) if operation == "relationship_groups": from .relationship_vocabulary import group_page, GROUP_PAGE_DEFAULT_ITEMS - view._require("router") return group_page(engine, snapshot, view.graph, offset=values.get("offset", 0), limit=values.get("limit", GROUP_PAGE_DEFAULT_ITEMS)) if operation == "related": - from tools.graph_engine.graph_engine import UnknownGroupError from .relationship_vocabulary import unknown_group_result try: return view.related(values["target"], tuple(values["groups"]), values["direction"], values["transitive"]) @@ -329,8 +336,6 @@ def application_dispatch(engine: StandardsEngine, operation: str, call): from tools.standards_applicability.standards_applicability import ApplicabilityError from .agent_navigation import with_route_content from .routing_inputs import bind_facts, binding_rejection - # Private vocabulary is interpreted only after Router qualification. - view._require("router") try: facts = bind_facts(compiled.router.fact_schema, values["facts"]) except (ApplicabilityError, ContractError) as error: @@ -342,8 +347,8 @@ def application_dispatch(engine: StandardsEngine, operation: str, call): if operation == "routing_facts": return view.routing_facts() return view.inspect(checked.handle) - except (_UnqualifiedContent, GraphError): - return application_rejection() + except (_UnknownTarget, GraphError) as error: + return _lookup_rejection(error) except engine._domain_errors() as error: failure = getattr(error, "failure", None) if getattr(failure, "outcome", None) == "unsupported": diff --git a/tools/standards_engine/standards_engine/engine.py b/tools/standards_engine/standards_engine/engine.py index a7b3f926..e9209cc3 100644 --- a/tools/standards_engine/standards_engine/engine.py +++ b/tools/standards_engine/standards_engine/engine.py @@ -475,8 +475,12 @@ def __init__( execution_context: AnalysisExecutionContext | None = None, temporary_store: tempfile.TemporaryDirectory[str] | None = None, compiled_cache: CompiledSnapshotCache | None = None, + route_page_bytes: int | None = None, ) -> None: + from .agent_navigation import admit_route_page_bytes + self._purpose = Purpose(purpose) + self._route_page_bytes = admit_route_page_bytes(route_page_bytes) if compiled_cache is not None: compiled_cache.require_scope(repository.root, self._purpose) self._compiled_cache = compiled_cache @@ -498,6 +502,7 @@ def open_repository( purpose: Purpose | str, execution_context: AnalysisExecutionContext | None = None, compiled_cache: CompiledSnapshotCache | None = None, + route_page_bytes: int | None = None, ) -> StandardsEngine: selected_purpose = Purpose(purpose) selected_root = root.resolve() @@ -520,12 +525,18 @@ def open_repository( execution_context=execution_context, temporary_store=temporary, compiled_cache=compiled_cache, + route_page_bytes=route_page_bytes, ) @property def purpose(self) -> Purpose: return self._purpose + @property + def route_page_bytes(self) -> int: + """Host-selected byte budget of one application route content page.""" + return self._route_page_bytes + def close(self) -> None: self._snapshots.close() if self._temporary_store is not None: diff --git a/tools/standards_engine/standards_engine/mcp.py b/tools/standards_engine/standards_engine/mcp.py index 0a74a5f8..123a39c7 100644 --- a/tools/standards_engine/standards_engine/mcp.py +++ b/tools/standards_engine/standards_engine/mcp.py @@ -17,6 +17,9 @@ from typing import Callable, TextIO from .tools import AgentToolFacade +from .agent_navigation import ( + ROUTE_CONTENT_RESULT_BYTES, ROUTE_PAGE_BYTES, ROUTE_PAGE_MIN_BYTES, admit_route_page_bytes, +) from .compiled_cache import CompiledSnapshotCache from .runtime_identity import RuntimeIdentity from .contract_discovery import ContractDiscovery @@ -29,6 +32,24 @@ PROTOCOL_VERSION = "2025-11-25" +# Every application client receives this text at initialize; keep it short and plain. +APPLICATION_INSTRUCTIONS = ( + "This server returns the engineering standards that apply to the task you are doing. " + "Get them before you plan or change code, then follow them.\n" + "1. Call routing_facts once. It lists every fact name and its allowed values; use them exactly as written.\n" + "2. Call route with the facts that are true of your task and content={{}}. Leave out a fact you do not know. " + "Do not remove a true fact to make a call succeed.\n" + "3. reading_plan lists every module that applies. content.items holds the full text of this page. " + "While content.next is present, call route again with exactly those arguments.\n" + "4. Keep the returned snapshot and pass it in every later call. A module you already hold at that snapshot " + "has not changed; do not read it again.\n" + "Each module has a review_state: current (this exact text was approved for application use), " + "changed-since-review (edited after it was approved) or not-reviewed (never approved). " + "All three are delivered and all apply; the label only tells you how settled the wording is.\n" + "read and read_many fetch modules by ID; ask for two or three per call so your client can show the whole result. " + "describe_input gives exact argument shapes when your client abbreviates them.\n" + "Installed interface {interface}; purpose application." +) class ProtocolError(Exception): @@ -40,10 +61,12 @@ def __init__(self, code: int, message: str, data: dict | None = None) -> None: class MCPServer: def __init__(self, root: Path, *, purpose: Purpose | str, advanced: bool = False, + route_page_bytes: int | None = None, output_schemas: OutputSchemaDelivery | str = OutputSchemaDelivery.EAGER, observation: RecorderConfig | None = None) -> None: self.root = root.resolve() self._purpose = Purpose(purpose) + self._route_page_bytes = admit_route_page_bytes(route_page_bytes) self.advanced = advanced self.output_schemas = OutputSchemaDelivery(output_schemas) self._interface = AgentToolFacade.load_interface(self.root) @@ -175,11 +198,12 @@ def _request(self, method: str, params: dict) -> dict: "capabilities": {"tools": {"listChanged": False}}, "serverInfo": {"name": "standards-engine", "version": self._runtime_identity.implementation_version}, "_meta": {"standards-engine/runtime": self._runtime_identity.metadata()}, - "instructions": f"Installed interface {self._interface.interface.interface_schema_version}; purpose {self.purpose.value}. Output schemas {self.output_schemas.value}. " + "instructions": APPLICATION_INSTRUCTIONS.format( + interface=self._interface.interface.interface_schema_version) + if self.purpose is Purpose.APPLICATION else + f"Installed interface {self._interface.interface.interface_schema_version}; purpose {self.purpose.value}. Output schemas {self.output_schemas.value}. " "Use describe_input for missing or abbreviated input shapes; retain its catalog-bound selections. " "Use describe_output only when an exact result contract is needed; ordinary results remain structured and server-validated. " + ( - "Use route with content={} to obtain applicable exact guidance; follow content.next for more. Reuse returned snapshots for consistent observations." - if self.purpose is Purpose.APPLICATION else "Use explicit routing facts and preserve opaque handles. Follow typed Engine outcomes and next_operations. Standards mutations belong to the Engine. Recovery-required continues through recover with the same context, never an apply retry." + ( " Native advanced operations use recover_application with readiness." @@ -217,6 +241,7 @@ def _request(self, method: str, params: dict) -> dict: with AgentToolFacade.open_repository( self.root, purpose=self.purpose, interface=self._interface, compiled_cache=self._compiled_cache, + route_page_bytes=self._route_page_bytes, ) as facade: value = getattr(facade, name)(arguments) except Exception as error: @@ -292,6 +317,12 @@ def main() -> int: action="store_true", help="Expose additional operations within the configured purpose.", ) + parser.add_argument( + "--route-page-bytes", type=int, + help=f"Application purpose only: byte budget of one route content page, measured on one JSON " + f"serialization of the result ({ROUTE_PAGE_MIN_BYTES} to {ROUTE_CONTENT_RESULT_BYTES}; default " + f"{ROUTE_PAGE_BYTES}). A page always holds at least one whole item.", + ) parser.add_argument( "--output-schemas", choices=[choice.value for choice in OutputSchemaDelivery], default=OutputSchemaDelivery.EAGER.value, @@ -307,6 +338,13 @@ def main() -> int: parser.add_argument('--observe-max-age-seconds', type=int, default=DEFAULT_MAX_AGE_SECONDS) parser.add_argument('--observe-max-bytes', type=int, default=DEFAULT_MAX_BYTES) arguments = parser.parse_args() + if arguments.route_page_bytes is not None: + if arguments.purpose != Purpose.APPLICATION.value: + parser.error("--route-page-bytes applies to the application purpose") + try: + admit_route_page_bytes(arguments.route_page_bytes) + except ValueError as error: + parser.error(str(error)) # Recording is on for every server process. Only these two switches turn it # off; in-process MCPServer construction records only when given a configuration. observation = None @@ -319,6 +357,7 @@ def main() -> int: parser.error(str(error)) serve( MCPServer(arguments.repo_root, purpose=arguments.purpose, advanced=arguments.advanced, + route_page_bytes=arguments.route_page_bytes, output_schemas=arguments.output_schemas, observation=observation), sys.stdin, sys.stdout, diff --git a/tools/standards_engine/standards_engine/mcp_catalog.py b/tools/standards_engine/standards_engine/mcp_catalog.py index 94c6db84..8cc4343d 100644 --- a/tools/standards_engine/standards_engine/mcp_catalog.py +++ b/tools/standards_engine/standards_engine/mcp_catalog.py @@ -100,8 +100,8 @@ "create_proposal": "Propose an atomic standards change with explicit domain intent and evidence against a snapshot.", "find_proposals": "Find durable proposals and their current revision handles.", "revise_proposal": "Append an atomic change to the exact expected proposal revision; stale revisions are rejected.", - "query_proposal": "Read, route, or traverse authoring content within an exact immutable proposal revision. Use preview_application to inspect its qualified application view.", - "preview_application": "Inspect an exact unpublished revision through the ordinary application qualification and filtering rules. Supply one read, route, or related request. Results and continuations stay bound to the draft; this operation neither publishes content nor approves review or exposure.", + "query_proposal": "Read, route, or traverse authoring content within an exact immutable proposal revision. Use preview_application to inspect its application view.", + "preview_application": "Inspect an exact unpublished revision as an application agent would receive it: every selected or named registered item is delivered with its review_state label (current, changed-since-review or not-reviewed). Supply one read, route, or related request. Results and continuations stay bound to the draft; this operation neither publishes content nor approves review or exposure.", "analyze_proposal": "Analyze an exact proposal revision and return unresolved consequences or complete analysis.", "review_proposal": "Accept complete current proposal analysis with explicit evidence-backed review decisions; return content-bound readiness. Requires user authorization for review.", "verify_proposal": "Verify the exact proposal candidate. Coverage audits require readiness. Verification does not supply review decisions or publish.", @@ -112,18 +112,19 @@ } +# Each application description opens with what the tool is for, in plain words. APPLICATION_DESCRIPTIONS = { - "describe_output": DESCRIPTIONS["describe_output"], - "relationship_groups": DESCRIPTIONS["relationship_groups"], - "describe_input": DESCRIPTIONS["describe_input"], - "runtime_info": DESCRIPTIONS["runtime_info"], - "read_many": "Read 1–32 selected reviewed items from one explicit snapshot in order. Each item supplies target and optional detail. The complete JSON result is limited to 2 MiB; an unavailable item rejects the whole request.", - "route": "Supply raw values in facts or one-field state markers for unknown/known-absent; omitted facts stay unknown. Types come from the qualified snapshot, not the request. Select applicable guidance from registered facts and a complete qualified dependency closure. Request content={} for selected exact guidance in this call: default 8, maximum 32 whole reads, 2 MiB total result. Follow content.next unchanged. Missing facts remain unresolved. Omit content for selection only; read_many accepts an explicit subset.", - "read": "Read a reviewed standard, example, or operational aid by identity. Full detail adds permitted relationships.", - "related": "Discover relationships among qualified guidance in one snapshot. Use relationship_groups for permitted IDs and meanings. Unknown groups return choices; an empty valid query remains successful.", - "routing_facts": "Read the reviewed vocabulary for routing a task. Supply known facts and retain unresolved conditions.", - "query": "Route, read, or traverse qualified guidance within the supplied snapshot.", - "inspect": "Inspect a permitted policy or relationship handle within its captured snapshot.", + "routing_facts": "Lists the facts you can state about a task: each fact's exact name, meaning, type and allowed values. Call it once, before your first route, and copy names and values exactly as listed. Omit snapshot to capture the current accepted standards; keep the returned snapshot and pass it to later calls.", + "route": "Returns the standards that apply to your task. Put the facts that are true of the task in facts, with names and values exactly as routing_facts lists them. Leave out a fact you do not know: it stays unknown and comes back in unresolved_questions. Do not remove a true fact to make a call succeed. For a fact you know is absent use {\"state\":\"known-absent\"}. Pass content={} to receive the text with the selection: reading_plan lists every selected module with its review_state, and content.items holds whole modules for this page. A page is sized for inline display (about 40 KB by default, at most content.limit items, default 8, maximum 32) and always holds at least one whole module. While content.next is present, call route again with exactly those arguments. Every selected module is delivered; review_state (current, changed-since-review or not-reviewed) says whether its text was approved for application use, not whether it applies. Omit snapshot on the first call and pass the returned snapshot afterwards. Omit content for the selection only.", + "read": "Returns the full text of one standard, example or operational aid by its ID, with its review_state. Use an ID exactly as a route, read or related result gave it; an unregistered ID is rejected, never guessed. detail=full adds the module's relationships. Pass the snapshot you already hold: a module you have read at that snapshot has not changed.", + "read_many": "Returns the full text of several modules by ID in one call, in the order asked, each with its review_state. Requires the snapshot returned by route or read. Each item gives target and optional detail. Ask for two or three modules per call so your client can show the whole result; the hard limits are 32 items and 2 MiB. An unregistered ID rejects the whole call and returns no items.", + "related": "Lists how one module relates to others, such as what it requires, specializes or affects. Name the groups to follow: relationship_groups lists the valid group IDs and the directions and transitive traversal each permits. An unknown group returns the valid choices. A valid query with no relationships is a normal empty result.", + "relationship_groups": "Lists the relationship group IDs that related accepts, with each group's meaning, permitted directions and whether transitive traversal is allowed. Pages hold 8 groups by default (maximum 32, 16 KiB); follow next exactly. Omit snapshot to capture the current accepted standards and reuse the returned snapshot with related. A listed group may have no relationships for a given module.", + "inspect": "Returns the detail behind a handle that an earlier result gave you: a policy handle returns that module in full, a relationship handle returns that relationship. Pass the handle unchanged.", + "query": "Advanced form of route, read and related: one native request against an explicit snapshot. Results carry the same review_state labels. Prefer route, read and related.", + "describe_input": "Shows the exact argument shape of a tool when your client abbreviates a field as unknown. Start with operation only. Read schema_json documents; $refs name selectable definitions. Select a referenced name with selector and expected_catalog from the result. Pages contain up to 16 whole records (default 8), 16 KiB result JSON; follow next unchanged for the complete selected closure. Reuse acquired shapes while catalog_digest matches. No standards state or permissions change.", + "describe_output": "Shows the exact result shape of a tool. Ordinary results are already structured, so you rarely need it. Start with operation; follow next for all records or select a referenced definition with expected_catalog. Combine root_schema_json with all records as $defs to validate a result. schema_digest binds the full output contract, not an approval.", + "runtime_info": "Reports which interface version, tool catalog and installation this running server has, without reading any standards. Supply expected_catalog to compare your client's catalog. Restart and reconnect after the server is replaced; refresh tools when only the client catalog differs.", } @@ -148,12 +149,15 @@ def tool_catalog( name = operation["id"] if not advanced and name not in FOCUSED_OPERATIONS: continue - description = APPLICATION_DESCRIPTIONS[name] if purpose is Purpose.APPLICATION else DESCRIPTIONS[name] + application = purpose is Purpose.APPLICATION + description = APPLICATION_DESCRIPTIONS[name] if application else DESCRIPTIONS[name] if name != "describe_input": - description = ( + hint = ( f'For abbreviated input fields, call describe_input(operation="{name}") ' - "and reuse the returned contract while its catalog matches. " + description + "and reuse the returned contract while its catalog matches." ) + # An application agent reads the tool's purpose first; the hint follows. + description = f"{description} {hint}" if application else f"{hint} {description}" if purpose is Purpose.AUTHORING and "agent" in operation.get("variants", {}): description += ( " Optional evidence maps request-local names to complete exact evidence references; " diff --git a/tools/standards_engine/standards_engine/tools.py b/tools/standards_engine/standards_engine/tools.py index ca40b574..f8e0a0bb 100644 --- a/tools/standards_engine/standards_engine/tools.py +++ b/tools/standards_engine/standards_engine/tools.py @@ -136,6 +136,7 @@ def open_repository( cls, root: Path, *, purpose: Purpose | str, interface: CompiledContracts | None = None, compiled_cache: CompiledSnapshotCache | None = None, + route_page_bytes: int | None = None, ) -> AgentToolFacade: repo_root = root.resolve() engine = StandardsEngine.open_repository( @@ -145,6 +146,7 @@ def open_repository( ), purpose=purpose, compiled_cache=compiled_cache, + route_page_bytes=route_page_bytes, ) try: return cls(engine, interface if interface is not None else _contracts(repo_root)) diff --git a/tools/standards_engine/tests/mcp_workflow_client.py b/tools/standards_engine/tests/mcp_workflow_client.py index d64bf2a0..72f0acf5 100644 --- a/tools/standards_engine/tests/mcp_workflow_client.py +++ b/tools/standards_engine/tests/mcp_workflow_client.py @@ -283,7 +283,7 @@ async def call(client, name, arguments, *, error=False): assert all(item["snapshot"] == visible["snapshot"] for item in grouped["items"]) assert "AUTHORING_SDK_MARKER_843015" not in json.dumps(grouped) hidden = await call(client, "read", {"target": "provenance.purpose-client"}, error=True) - assert hidden["code"] == "APPLICATION.CONTENT_UNAVAILABLE", hidden + assert hidden["code"] == "APPLICATION.UNKNOWN_TARGET", hidden return { "client": "official MCP Python SDK", diff --git a/tools/standards_engine/tests/test_capture_handoff_transport.py b/tools/standards_engine/tests/test_capture_handoff_transport.py index afe05149..746c3b2f 100644 --- a/tools/standards_engine/tests/test_capture_handoff_transport.py +++ b/tools/standards_engine/tests/test_capture_handoff_transport.py @@ -12,6 +12,7 @@ import subprocess import sys import tempfile +import tomllib import unittest from tools.standards_engine.tests.test_analysis import _clone_tracked_worktree @@ -74,7 +75,9 @@ def call(method, params=None): try: initialized = call('initialize',{'protocolVersion':'2025-11-25','capabilities':{}, 'clientInfo':{'name':'capture-handoff-fixture','version':'1'}}) - self.assertEqual(initialized['_meta']['standards-engine/runtime']['interface_version'],48) + installed = tomllib.loads((self.root/'tools/standards_engine/contracts/a1-interface.toml').read_text()) + self.assertEqual(initialized['_meta']['standards-engine/runtime']['interface_version'], + installed['interface_schema_version']) process.stdin.write('{"jsonrpc":"2.0","method":"notifications/initialized"}\n') process.stdin.flush() def tool(name, arguments): diff --git a/tools/standards_engine/tests/test_consumer_publication.py b/tools/standards_engine/tests/test_consumer_publication.py index 4d01fa31..fe24ae9a 100644 --- a/tools/standards_engine/tests/test_consumer_publication.py +++ b/tools/standards_engine/tests/test_consumer_publication.py @@ -126,8 +126,11 @@ def test_same_candidate_registration_preview_review_publication_and_cold_readbac self.assertEqual(preview['revision'],revision) self.assertNotIn('snapshot',preview);self.assertNotIn('handle',preview['policy']) self.assertNotIn('AUTHORING_PRIVATE_8159',json.dumps(preview)) - hidden=self.call('preview_application',{'revision':revision,'request':{'kind':'read','target':F.document}},error=True) - self.assertEqual(hidden['code'],'APPLICATION.CONTENT_UNAVAILABLE') + labelled=self.call('preview_application',{'revision':revision,'request':{'kind':'read','target':F.document}}) + self.assertEqual((labelled['kind'],labelled['review_state']),('candidate-application-read-result','not-reviewed')) + self.assertEqual(preview['review_state'],'current') + unknown=self.call('preview_application',{'revision':revision,'request':{'kind':'read','target':'provenance.consumer-test'}},error=True) + self.assertEqual(unknown['code'],'APPLICATION.UNKNOWN_TARGET') denied=self.rpc('tools/call',{'name':'preview_application','arguments':{'revision':revision,'request':{'kind':'read','target':F.owner}}},'application') self.assertIn('error',denied) # A fresh process reconstructs the draft after unrelated working-tree drift. @@ -157,8 +160,12 @@ def test_same_candidate_registration_preview_review_publication_and_cold_readbac for path in (F.fixture_path,F.second_path): self.assertEqual(subprocess.check_output(['git','show','main:'+path],cwd=self.root),original[path]) self.assertIn(b'Apply the owned rule.',subprocess.check_output(['git','show','main:'+F.doc_path],cwd=self.root)) - self.call('read',{'target':'provenance.consumer-test'},purpose='application',error=True) - self.call('read',{'target':F.document},purpose='application',error=True) + self.assertEqual(exposed['review_state'],'current') + hidden=self.call('read',{'target':'provenance.consumer-test'},purpose='application',error=True) + self.assertEqual(hidden['code'],'APPLICATION.UNKNOWN_TARGET') + document=self.call('read',{'target':F.document},purpose='application') + self.assertEqual(document['review_state'],'not-reviewed') + self.assertIn('Apply the owned rule.',document['content']) self.assertEqual(self.call('preview_application',{'revision':revision,'request':{'kind':'read','target':F.owner,'detail':'full'}}),preview) self.assertNotEqual(subprocess.check_output(['git','rev-parse','main'],cwd=self.root),before) diff --git a/tools/standards_engine/tests/test_input_discovery.py b/tools/standards_engine/tests/test_input_discovery.py index 1810b75c..e4d36b54 100644 --- a/tools/standards_engine/tests/test_input_discovery.py +++ b/tools/standards_engine/tests/test_input_discovery.py @@ -84,7 +84,14 @@ def test_flat_discovery_schema_and_early_guidance_cover_every_published_tool(sel self.assertTrue(tool['annotations']['readOnlyHint']) for item in server.tools: if item['name'] != 'describe_input': - self.assertIn(f'describe_input(operation="{item["name"]}")', item['description'][:250]) + hint = (f'For abbreviated input fields, call describe_input(operation="{item["name"]}") ' + 'and reuse the returned contract while its catalog matches.') + # Application descriptions open with the tool's purpose and end with the hint. + if purpose == 'application': + self.assertTrue(item['description'].endswith(' ' + hint), item['name']) + self.assertNotIn('describe_input(operation=', item['description'][:-len(hint)]) + else: + self.assertTrue(item['description'].startswith(hint + ' '), item['name']) def test_every_published_input_can_be_reconstructed_and_independently_validated(self): for purpose in ('application', 'authoring'): diff --git a/tools/standards_engine/tests/test_proposal_consumers.py b/tools/standards_engine/tests/test_proposal_consumers.py index 8035adc2..8801e216 100644 --- a/tools/standards_engine/tests/test_proposal_consumers.py +++ b/tools/standards_engine/tests/test_proposal_consumers.py @@ -198,7 +198,7 @@ def test_existing_canonical_identity_and_artifact_alias_are_not_rebound(self): with self.subTest(identity=identity),self.assertRaises(AuthoringError): self.project([self.bound([registration(identity,self.fixture_path)])]) - def test_candidate_view_uses_same_qualification_without_published_handles(self): + def test_candidate_view_uses_same_delivery_and_labels_without_published_handles(self): from tools.standards_engine.standards_engine.context_projection import ApplicationView, preview_application from tools.standards_engine.standards_engine import _generated_contract as c result=self.project([self.bound(self.initial_edits())]) @@ -210,15 +210,28 @@ def test_candidate_view_uses_same_qualification_without_published_handles(self): self.assertEqual(value['content'],normal['content']) self.assertEqual(value['requires'],normal['requires']) self.assertEqual(value['kind'],'candidate-application-read-result') + self.assertEqual((value['review_state'],normal['review_state']),('current','current')) self.assertNotIn('snapshot',value);self.assertNotIn('handle',value['policy']) import json self.assertNotIn('AUTHORING_PRIVATE_8159',json.dumps(value)) self.assertNotIn('fixture.first',json.dumps(value)) - for target in [self.document,'provenance.consumer-test','fixture.first']: + def preview(target): call=c.PreviewApplicationCall.from_value({'revision':revision.as_contract(),'request':{'kind':'read','target':target}}) - denied=preview_application(None,result.compiled,call).as_contract() + return preview_application(None,result.compiled,call).as_contract() + # Registered documentation without an approval is delivered with its label. + document=preview(self.document) + self.assertEqual(document['kind'],'candidate-application-read-result') + self.assertEqual(document['review_state'],'not-reviewed') + self.assertEqual(document['content'],'# Correct Consumer Guidance\n\nApply the owned rule.\n') + self.assertEqual(document['review_state'],ApplicationView(result.compiled,snapshot).read(self.document).as_contract()['review_state']) + # Authoring provenance and unregistered consumers are not application material. + for target in ['provenance.consumer-test','fixture.first','topic.consumer-fixture.misspelt']: + denied=preview(target) self.assertEqual(denied['kind'],'candidate-application-rejected-result') + self.assertEqual((denied['code'],denied['outcome']),('APPLICATION.UNKNOWN_TARGET','invalid')) + self.assertIn('not registered',denied['message']) self.assertEqual(denied['revision'],revision.as_contract()) + self.assertNotIn('AUTHORING_PRIVATE_8159',json.dumps(denied)) class CandidateProjectionTests(unittest.TestCase): @@ -267,15 +280,53 @@ def test_related_result_uses_revision_bound_continuations(self): self.assertTrue(candidate['next_operations']) self.assertTrue(all(op['operation']=='preview_application' for op in candidate['next_operations'])) - def test_stale_exposure_is_rejected_without_partial_candidate_content(self): + def test_stale_exposure_is_labelled_in_delivered_candidate_content(self): files=dict(self.state.files) files['CORE-STANDARDS.md']+=b'\nUNAPPROVED_NEW_MATERIAL\n' compiled=self.fixture.compile_files(files) - for request in ({'kind':'read','target':'core'}, {'kind':'route','facts':{}}): - result=self.preview(request,compiled) - self.assertEqual(result['code'],'APPLICATION.CONTENT_UNAVAILABLE') - self.assertEqual(result['revision'],self.revision.as_contract()) - self.assertNotIn('content',result) + read=self.preview({'kind':'read','target':'core'},compiled) + self.assertEqual(read['kind'],'candidate-application-read-result') + self.assertEqual(read['review_state'],'changed-since-review') + self.assertIn('UNAPPROVED_NEW_MATERIAL',read['content']) + self.assertEqual(read['revision'],self.revision.as_contract()) + route=self.preview({'kind':'route','facts':{}},compiled) + self.assertEqual(route['kind'],'candidate-application-route-result') + labels={entry['target']:entry['review_state'] for entry in route['reading_plan']} + self.assertEqual(labels['core'],'changed-since-review') + self.assertEqual(labels['router'],'current') + + def test_preview_and_published_application_agree_on_labels_and_rejections(self): + import json + facts={'routing.'+key:{'type':'enum-set','state':'known','value':['implementation'] if key=='activities' else []} + for key in ('activities','workflow-profiles','applications','boundaries','languages','frameworks','topics','details')} + candidate=self.preview({'kind':'route','facts':facts}) + published=self.state.facade.query({'snapshot':self.state.snapshot,'request':{'kind':'route','facts':facts}}) + self.assertEqual(candidate['kind'],'candidate-application-route-result') + for field in ('status','reading_plan','unresolved_questions'): + self.assertEqual(candidate[field],published[field]) + labels={entry['target']:entry['review_state'] for entry in candidate['reading_plan']} + self.assertEqual(labels['workflow.implementation'],'not-reviewed') + self.assertEqual(labels['core'],'current') + for operation in candidate['next_operations']: + read=self.preview(operation['request']) + normal=self.state.facade.read({'snapshot':self.state.snapshot,'target':operation['request']['target']}) + for field in ('review_state','content','scope','requires','specializes'): + self.assertEqual(read[field],normal[field]) + self.assertEqual(read['review_state'],labels[operation['request']['target']]) + requests=[({'kind':'read','target':'does.not.exist'},'APPLICATION.UNKNOWN_TARGET'), + ({'kind':'related','target':'does.not.exist','groups':['semantic'],'direction':'outgoing','transitive':False},'APPLICATION.UNKNOWN_TARGET'), + ({'kind':'related','target':'core','groups':['plausible-but-invalid'],'direction':'outgoing','transitive':False},'APPLICATION.UNKNOWN_GROUP'), + ({'kind':'related','target':'core','groups':['policy-impact'],'direction':'outgoing','transitive':True},'APPLICATION.TRAVERSAL_NOT_PERMITTED')] + for request,code in requests: + with self.subTest(request=request): + rejected=self.preview(request) + normal=self.state.facade.query({'snapshot':self.state.snapshot,'request':request}) + self.assertEqual(rejected['kind'],'candidate-application-rejected-result') + for field in ('code','outcome','message'): + self.assertEqual(rejected[field],normal[field]) + self.assertEqual(rejected['code'],code) + self.assertEqual(rejected['revision'],self.revision.as_contract()) + self.assertNotIn('awaiting',json.dumps(rejected)) if __name__ == '__main__': diff --git a/tools/standards_engine/tests/test_purpose_projection.py b/tools/standards_engine/tests/test_purpose_projection.py index 1dbde1c7..e20adcf0 100644 --- a/tools/standards_engine/tests/test_purpose_projection.py +++ b/tools/standards_engine/tests/test_purpose_projection.py @@ -1,4 +1,4 @@ -"""Focused exposure evidence over captured content and the actual SQLite store.""" +"""Focused review-label evidence over captured content and the actual SQLite store.""" from __future__ import annotations from dataclasses import replace @@ -92,7 +92,8 @@ def test_read_has_exact_reviewed_content_and_explicit_permitted_fields(self): self.assertEqual(value["content"], self.files["CORE-STANDARDS.md"].decode()) self.assertIn(PUBLIC, value["content"]) self.assertNotIn(PRIVATE, json.dumps(value)) - self.assertEqual(set(value), {"kind", "purpose", "snapshot", "policy", "content", "scope", "requires", "specializes", "next_operations"} | ({"related"} if detail == "full" else set())) + self.assertEqual(set(value), {"kind", "purpose", "snapshot", "policy", "review_state", "content", "scope", "requires", "specializes", "next_operations"} | ({"related"} if detail == "full" else set())) + self.assertEqual(value["review_state"], "current") self.assertNotIn("provenance", value) def test_direct_hidden_read_and_privileged_request_are_bounded(self): @@ -144,17 +145,141 @@ def test_material_change_requires_new_exposure_but_rationale_change_does_not(sel self.assertEqual(reason.materials["core"].binding, self.compiled.materials["core"].binding) self.assertEqual(reason.supporting.exposure_state("core", reason.materials["core"].binding), "current") - def test_routing_retains_unknown_facts_and_blocks_missing_required_content(self): + def capture(self, files, label): + captured = self.engine._snapshots.create_snapshot(CapturedContent(label, ( + SnapshotFile(SnapshotPath.parse(path), value) for path, value in refresh(dict(files)).files))) + return self.engine._snapshot_handle(captured.snapshot) + + def implementation_facts(self): + facts = {"routing."+key: [] + for key in ("activities", "workflow-profiles", "applications", "boundaries", "languages", "frameworks", "topics", "details")} + facts["routing.activities"] = ["implementation"] + return facts + + def test_routing_retains_unknown_facts_and_delivers_unapproved_selected_content(self): unknown = self.facade.route({"snapshot": self.snapshot, "facts": {}}) self.assertEqual(unknown["status"], "needs-facts", unknown) self.assertTrue(unknown["unresolved_questions"]) - facts = {"routing."+key: [] - for key in ("activities", "workflow-profiles", "applications", "boundaries", "languages", "frameworks", "topics", "details")} - complete = self.facade.route({"snapshot": self.snapshot, "facts": facts}) + facts = self.implementation_facts() + complete = self.facade.route({"snapshot": self.snapshot, "facts": {**facts, "routing.activities": []}}) self.assertEqual(complete["status"], "complete", complete) - facts["routing.activities"] = ["implementation"] - blocked = self.facade.route({"snapshot": self.snapshot, "facts": facts}) - self.assertEqual(blocked["code"], "APPLICATION.CONTENT_UNAVAILABLE", blocked) + self.assertEqual({entry["review_state"] for entry in complete["reading_plan"]}, {"current"}) + selected = self.facade.route({"snapshot": self.snapshot, "facts": facts}) + self.assertEqual(selected["kind"], "application-route-result", selected) + self.assertEqual(selected["status"], "complete") + labels = {entry["target"]: entry["review_state"] for entry in selected["reading_plan"]} + self.assertGreater(len(labels), len(complete["reading_plan"])) + self.assertEqual(labels["core"], "current") + self.assertEqual(labels["workflow.implementation"], "not-reviewed") + self.assertEqual([hint["target"] for hint in selected["next_operations"]], + [entry["target"] for entry in selected["reading_plan"]]) + + def test_route_delivers_not_reviewed_and_changed_modules_with_correct_labels(self): + files = dict(self.files) + target = "workflow.implementation" + material = self.compiled.materials[target] + entries = [{"target": key, "binding": value.binding} for key, value in self.compiled.supporting.exposure.items()] + entries.append({"target": target, "binding": material.binding}) + files[APPLICATION_CONTENT] = ("schema_version = 1\nentries = " + _toml_inline(entries) + "\n").encode() + approved = self.facade.read({"snapshot": self.capture(files, "approved-fixture"), "target": target}) + self.assertEqual(approved["review_state"], "current", approved) + files[material.path] += b"\nEDITED_AFTER_APPROVAL_52871\n" + snapshot = self.capture(files, "changed-fixture") + facts = {**self.implementation_facts(), "routing.languages": ["rust"]} + arguments = {"snapshot": snapshot, "facts": facts, "content": {}} + plan, items = None, [] + while arguments is not None: + value = self.facade.route(arguments) + self.assertEqual(value["kind"], "application-route-result", value) + plan = value["reading_plan"] + items.extend(value["content"]["items"]) + arguments = value["content"].get("next") + labels = {entry["target"]: entry["review_state"] for entry in plan} + self.assertEqual(labels[target], "changed-since-review") + self.assertEqual(labels["core"], "current") + self.assertEqual(labels["profile.language.rust"], "not-reviewed") + self.assertEqual(set(labels.values()), {"current", "changed-since-review", "not-reviewed"}) + # Every selected module arrives, and each item repeats its plan label beside the text. + self.assertEqual([item["policy"]["id"] for item in items], list(labels)) + self.assertEqual({item["policy"]["id"]: item["review_state"] for item in items}, labels) + changed = next(item for item in items if item["policy"]["id"] == target) + self.assertIn("EDITED_AFTER_APPROVAL_52871", changed["content"]) + self.assertNotIn(PRIVATE, json.dumps(items)) + many = self.facade.read_many({"snapshot": snapshot, "items": [{"target": key} for key in labels]}) + self.assertEqual(many["items"], items) + unit = self.compiled.corpus.policy_unit_corpus.for_module(target)[0] + scoped = self.facade.read({"snapshot": snapshot, "target": unit.id}) + self.assertEqual(scoped["review_state"], "changed-since-review", scoped) + + def test_router_and_core_with_lapsed_or_absent_approval_still_route(self): + lapsed = dict(self.files) + lapsed["CORE-STANDARDS.md"] += b"\nCORE_EDITED_AFTER_APPROVAL_30417\n" + path = "evaluation/standards-effectiveness/router-projection.toml" + lapsed[path] = lapsed[path].replace(self.compiled.router.facts[0].prompt.encode(), + b"Describe the selected task activities.", 1) + absent = dict(self.files) + absent[APPLICATION_CONTENT] = b"schema_version = 1\nentries = []\n" + for files, expected in ((lapsed, "changed-since-review"), (absent, "not-reviewed")): + with self.subTest(expected=expected): + snapshot = self.capture(files, "lapsed-" + expected) + vocabulary = self.facade.routing_facts({"snapshot": snapshot}) + self.assertEqual(vocabulary["kind"], "application-routing-facts-result", vocabulary) + self.assertTrue(vocabulary["facts"]) + groups = self.facade.relationship_groups({"snapshot": snapshot}) + self.assertEqual(groups["kind"], "relationship-groups-result", groups) + routed = self.facade.route({"snapshot": snapshot, "facts": self.implementation_facts(), "content": {}}) + self.assertEqual(routed["kind"], "application-route-result", routed) + labels = {entry["target"]: entry["review_state"] for entry in routed["reading_plan"]} + self.assertEqual(labels["core"], expected) + self.assertEqual(labels["router"], expected) + self.assertEqual(routed["content"]["items"][0]["policy"]["id"], "core") + self.assertEqual(routed["content"]["items"][0]["review_state"], expected) + related = self.facade.related({"snapshot": snapshot, "target": "router", "groups": ["standards-requires"], + "direction": "outgoing", "transitive": False}) + self.assertEqual(related["kind"], "application-related-result", related) + self.assertEqual(self.facade.read({"snapshot": snapshot, "target": "router"})["review_state"], expected) + + def test_unknown_target_has_its_own_rejection_and_nothing_awaits_publication(self): + handle = self.read()["policy"]["handle"] + rejections = [ + self.facade.read({"snapshot": self.snapshot, "target": "core.misspelt"}), + self.facade.read({"snapshot": self.snapshot, "target": "provenance.fixture"}), + self.facade.related({"snapshot": self.snapshot, "target": "does.not.exist", "groups": ["semantic"], + "direction": "outgoing", "transitive": False}), + self.facade.read_many({"snapshot": self.snapshot, "items": [{"target": "core"}, {"target": "does.not.exist"}]}), + self.facade.inspect({"handle": {**handle, "child_id": "does.not.exist"}}), + self.facade.inspect({"handle": {**handle, "child_kind": "relationship", "child_id": "outgoing:does.not.exist"}}), + self.facade.inspect({"handle": {**handle, "child_kind": "relationship", "child_id": "sideways:core"}}), + ] + for value in rejections: + self.assertEqual(value["kind"], "application-rejected-result", value) + self.assertEqual((value["code"], value["outcome"]), ("APPLICATION.UNKNOWN_TARGET", "invalid"), value) + self.assertIn("not registered", value["message"]) + self.assertIn("returned by route, read or related", value["message"]) + self.assertNotIn(PRIVATE, json.dumps(value)) + forbidden = self.facade.related({"snapshot": self.snapshot, "target": "core", "groups": ["policy-impact"], + "direction": "outgoing", "transitive": True}) + self.assertEqual(forbidden["code"], "APPLICATION.TRAVERSAL_NOT_PERMITTED", forbidden) + self.assertIn("relationship_groups", forbidden["message"]) + definition = _contracts(ROOT).schema["$defs"]["ApplicationRejectedResult"] + self.assertNotIn("APPLICATION.CONTENT_UNAVAILABLE", definition["properties"]["code"]["enum"]) + self.assertNotIn("awaiting", json.dumps(rejections + [forbidden])) + + def test_application_graph_holds_all_registered_material_and_no_provenance(self): + view = ApplicationView(self.compiled, c.SnapshotHandle.from_value(self.snapshot)) + self.assertEqual(set(view.review), set(self.compiled.materials)) + self.assertIn("not-reviewed", view.review.values()) + self.assertLessEqual(set(self.compiled.materials) & set(self.compiled.graph.nodes), set(view.graph.nodes)) + self.assertEqual(set(view.graph.groups), {"standards-requires", "standards-specializes", + "standards-dependencies", "policy-impact", "semantic"}) + self.assertFalse([node for node in view.graph.nodes if node.startswith("provenance.")]) + hidden = set(view.graph.nodes) - set(self.compiled.materials) - {unit.id for unit in self.compiled.corpus.policy_units} + self.assertEqual(hidden, set()) + # An unapproved module is a relationship endpoint like any other. + related = self.facade.related({"snapshot": self.snapshot, "target": "workflow.implementation", + "groups": ["standards-requires"], "direction": "outgoing", "transitive": False}) + self.assertEqual(related["kind"], "application-related-result", related) + self.assertIn("core", [entry["target"] for entry in related["relationships"]]) def test_hidden_intermediate_cannot_bridge_a_permitted_traversal(self): from tools.graph_engine.graph_engine import ( @@ -216,6 +341,44 @@ def test_catalog_has_no_authoring_schema_closure(self): for hidden in ("rationale", "ChangePurpose", "DecisionProvenanceRecord", "ProposalRevisionHandle"): self.assertNotIn(hidden, serialized) + def test_application_descriptions_open_with_purpose_and_state_no_gate(self): + from tools.standards_engine.standards_engine.mcp_catalog import tool_catalog + interface = AgentToolFacade.load_interface(ROOT) + for delivery in ("eager", "on-demand"): + catalog = {tool["name"]: tool["description"] for tool in + tool_catalog(interface, purpose="application", advanced=True, output_schemas=delivery)} + for name, description in catalog.items(): + with self.subTest(delivery=delivery, name=name): + self.assertRegex(description, r"^(Returns|Lists|Shows|Reports|Advanced form) ") + for stale in ("awaiting", "unavailable item", "reviewed items", "qualified"): + self.assertNotIn(stale, description) + self.assertNotIn("2 MiB", catalog["route"]) + for phrase in ("content={}", "content.next", "review_state", "not-reviewed", "at least one whole module"): + self.assertIn(phrase, catalog["route"]) + self.assertIn("two or three modules per call", catalog["read_many"]) + authoring = {tool["name"]: tool["description"] for tool in tool_catalog(interface, purpose="authoring")} + self.assertIn("review_state", authoring["preview_application"]) + self.assertNotIn("qualification", authoring["preview_application"]) + + def test_application_skill_example_uses_the_registered_vocabulary_and_labels(self): + skill = (ROOT / ".agents/skills/coding-standards/SKILL.md").read_text() + self.assertTrue(skill.startswith("---\nname: coding-standards\ndescription: "), skill[:80]) + facts = {fact["id"]: fact["values"] for fact in self.compiled.router.fact_definitions()} + example = {"routing.activities": "implementation", "routing.languages": "rust", "routing.boundaries": "interop"} + for name, value in example.items(): + self.assertIn(value, facts[name]) + self.assertIn(f'"{name}": ["{value}"]', skill) + labels = _contracts(ROOT).schema["$defs"]["ApplicationReviewState"]["enum"] + self.assertEqual(labels, ["current", "changed-since-review", "not-reviewed"]) + for phrase in (*(f"`{label}`" for label in labels), "routing_facts", "content: {}", "content.next", + "snapshot", "read_many", "APPLICATION.UNKNOWN_TARGET"): + self.assertIn(phrase, skill) + routed = self.facade.route({"snapshot": self.snapshot, "content": {}, + "facts": {name: [value] for name, value in example.items()}}) + self.assertEqual(routed["kind"], "application-route-result", routed) + for entry in routed["reading_plan"]: + self.assertIn(entry["target"], skill) + def test_whole_module_discovers_references_owned_by_its_policy_units(self): from tools.graph_engine.graph_engine import ( diff --git a/tools/standards_engine/tests/test_purpose_transport.py b/tools/standards_engine/tests/test_purpose_transport.py index ba18e8a7..7c4c22ab 100644 --- a/tools/standards_engine/tests/test_purpose_transport.py +++ b/tools/standards_engine/tests/test_purpose_transport.py @@ -112,7 +112,13 @@ def request(identifier, method, params): self.assertEqual(allowed["structuredContent"]["content"], self.expected) self.assertEqual(json.loads(allowed["content"][0]["text"]), allowed["structuredContent"]) self.assertTrue(values[4]["result"]["isError"]) - self.assertEqual(values[4]["result"]["structuredContent"]["code"], "APPLICATION.CONTENT_UNAVAILABLE") + self.assertEqual(values[4]["result"]["structuredContent"]["code"], "APPLICATION.UNKNOWN_TARGET") + self.assertEqual(allowed["structuredContent"]["review_state"], "current") + instructions = values[1]["result"]["instructions"] + for phrase in ("routing_facts", "content={}", "content.next", "snapshot", "review_state", + "current", "changed-since-review", "not-reviewed"): + self.assertIn(phrase, instructions) + self.assertNotIn("awaiting", instructions) self.assertIn("error", values[5]) diff --git a/tools/standards_engine/tests/test_read_many.py b/tools/standards_engine/tests/test_read_many.py index 74414e30..c758bcab 100644 --- a/tools/standards_engine/tests/test_read_many.py +++ b/tools/standards_engine/tests/test_read_many.py @@ -108,10 +108,20 @@ def test_empty_duplicate_oversized_missing_snapshot_and_privileged_requests_reje self.assertEqual(result["code"], "APPLICATION.INPUT_INVALID", result) self.assertNotIn("items", result) + def test_unapproved_items_are_delivered_in_order_with_their_labels(self): + items = [{"target": "workflow.implementation"}, {"target": "core"}, {"target": "profile.language.rust", "detail": "full"}] + result = self.call(items=items) + self.assertEqual(result["kind"], "application-read-many-result", result) + self.assertEqual([(item["policy"]["id"], item["review_state"]) for item in result["items"]], + [("workflow.implementation", "not-reviewed"), ("core", "current"), + ("profile.language.rust", "not-reviewed")]) + self.assertEqual(result["items"], [self.app.read({"snapshot": self.snapshot, **item}) for item in items]) + self.assertNotIn(fixture.PRIVATE, json.dumps(result)) + def test_unknown_or_private_item_rejects_whole_set_without_partial_data(self): for target in ("does.not.exist", "provenance.fixture"): result = self.call(items=[{"target": "core"}, {"target": target}]) - self.assertEqual(result["code"], "APPLICATION.CONTENT_UNAVAILABLE", result) + self.assertEqual(result["code"], "APPLICATION.UNKNOWN_TARGET", result) self.assertNotIn(fixture.PUBLIC, json.dumps(result)) self.assertNotIn(fixture.PRIVATE, json.dumps(result)) self.assertNotIn("items", result) diff --git a/tools/standards_engine/tests/test_registration_contract.py b/tools/standards_engine/tests/test_registration_contract.py index d67d7bd3..1e7af16d 100644 --- a/tools/standards_engine/tests/test_registration_contract.py +++ b/tools/standards_engine/tests/test_registration_contract.py @@ -127,7 +127,7 @@ def test_checked_in_contract_projections_are_current(self) -> None: self.assertEqual(generated_tools.read_text(), self.artifacts.agent_tools_json) self.assertEqual(self.artifacts.agent_tools["interface_schema_version"], self.interface["interface_schema_version"]) self.assertEqual(self.interface["request_contract_version"], 6) - self.assertEqual(self.interface["result_projection_version"], 8) + self.assertEqual(self.interface["result_projection_version"], 9) def test_authored_contract_examples_match_the_current_interface(self) -> None: examples = json.loads((CONTRACTS / "examples/a1-examples.json").read_text()) diff --git a/tools/standards_engine/tests/test_relationship_vocabulary.py b/tools/standards_engine/tests/test_relationship_vocabulary.py index 3df57250..595b1834 100644 --- a/tools/standards_engine/tests/test_relationship_vocabulary.py +++ b/tools/standards_engine/tests/test_relationship_vocabulary.py @@ -77,9 +77,25 @@ def test_unknown_query_offers_same_first_page_and_choices_repair_it(self): def test_hidden_target_is_not_a_way_to_read_private_application_groups(self): result = self.app.related({'snapshot': self.snapshot, 'target': 'provenance.fixture', 'groups': ['decision-provenance'], 'direction': 'outgoing', 'transitive': False}) - self.assertEqual(result['code'], 'APPLICATION.CONTENT_UNAVAILABLE') + self.assertEqual(result['code'], 'APPLICATION.UNKNOWN_TARGET') self.assertNotIn('relationship_groups', result) self.assertNotIn(fixture.PRIVATE, json.dumps(result)) + # A registered target still cannot select the authoring-only group. + result = self.app.related({'snapshot': self.snapshot, 'target': 'core', + 'groups': ['decision-provenance'], 'direction': 'outgoing', 'transitive': False}) + self.assertEqual(result['code'], 'APPLICATION.UNKNOWN_GROUP') + self.assertNotIn('decision-provenance', json.dumps(result['relationship_groups'])) + self.assertNotIn(fixture.PRIVATE, json.dumps(result)) + + def test_unpermitted_application_traversal_names_the_vocabulary(self): + group = next(item for item in self.page(self.app, limit=32)['items'] if not item['transitive']) + result = self.app.related({'snapshot': self.snapshot, 'target': 'core', 'groups': [group['id']], + 'direction': 'outgoing', 'transitive': True}) + self.assertEqual((result['code'], result['outcome']), ('APPLICATION.TRAVERSAL_NOT_PERMITTED', 'invalid')) + self.assertIn('relationship_groups', result['message']) + allowed = self.app.related({'snapshot': self.snapshot, 'target': 'core', 'groups': [group['id']], + 'direction': 'outgoing', 'transitive': False}) + self.assertEqual(allowed['kind'], 'application-related-result', allowed) def test_byte_bounds_whole_records_and_numeric_equivalence(self): for facade in (self.author, self.app): diff --git a/tools/standards_engine/tests/test_route_content.py b/tools/standards_engine/tests/test_route_content.py index 12571987..ba50f841 100644 --- a/tools/standards_engine/tests/test_route_content.py +++ b/tools/standards_engine/tests/test_route_content.py @@ -1,15 +1,20 @@ -"""Routed exact content across qualification, paging and lifecycle boundaries.""" +"""Routed exact content across review labels, paging and lifecycle boundaries.""" from __future__ import annotations from copy import deepcopy import json +import os from pathlib import Path +import subprocess +import sys import unittest from unittest.mock import patch from tools.standards_engine.standards_engine import AgentToolFacade, StandardsEngine from tools.standards_engine.standards_engine import agent_navigation +from tools.standards_engine.standards_engine.mcp import MCPServer from tools.standards_engine.standards_engine.tools import _contracts +from tools.standards_engine.tests.test_mcp import initialize, request from tools.standards_engine.tests import test_purpose_projection as fixture from tools.standards_snapshots.standards_snapshots import SnapshotId @@ -87,35 +92,84 @@ def test_one_verified_input_and_no_capture_for_each_composed_call(self): self.assertEqual(compiled.call_count, 1) self.assertEqual(load.call_count, 1) - def test_unqualified_later_target_blocks_even_a_one_item_application_page(self): + def test_unapproved_later_target_is_delivered_with_its_label_on_its_own_page(self): facts = known_assertions() facts['routing.activities'] = ['implementation'] value = self.route(self.app, facts=facts, content={'limit': 1}) - self.assertEqual(value['code'], 'APPLICATION.CONTENT_UNAVAILABLE') - self.assertNotIn('content', value) - self.assertNotIn(fixture.PRIVATE, json.dumps(value)) + self.assertEqual(value['kind'], 'application-route-result', value) + labels = {entry['target']: entry['review_state'] for entry in value['reading_plan']} + self.assertEqual(labels['workflow.implementation'], 'not-reviewed') + items = list(value['content']['items']) + while 'next' in value['content']: + value = self.app.route(value['content']['next']) + items.extend(value['content']['items']) + self.assertEqual({item['policy']['id']: item['review_state'] for item in items}, labels) + self.assertEqual(items, [self.app.read({'snapshot': self.snapshot, 'target': target}) for target in labels]) + self.assertNotIn(fixture.PRIVATE, json.dumps(items)) def test_exact_byte_limit_partial_pages_and_oversized_record(self): for facade in (self.author, self.app): + application = facade is self.app + + def budget(size): + # Authoring pages keep the transport bound; application pages use the host budget. + return (patch.object(facade._engine, '_route_page_bytes', size) if application + else patch.object(agent_navigation, 'ROUTE_CONTENT_RESULT_BYTES', size)) + first = self.route(facade, content={'limit': 1}) full = self.route(facade, content={'limit': 2}) full_bytes = len(json.dumps(full).encode('utf-8')) - with patch.object(agent_navigation, 'ROUTE_CONTENT_RESULT_BYTES', full_bytes): + with budget(full_bytes): self.assertEqual(self.route(facade, content={'limit': 2}), full) first_bytes = len(json.dumps(first).encode('utf-8')) self.assertLess(first_bytes, full_bytes) - with patch.object(agent_navigation, 'ROUTE_CONTENT_RESULT_BYTES', first_bytes): + with budget(first_bytes): partial = self.route(facade, content={'limit': 2}) self.assertEqual(partial['content']['items'], first['content']['items']) self.assertEqual(partial['content']['next']['content']['offset'], 1) self.assertLessEqual(len(json.dumps(partial).encode('utf-8')), first_bytes) + with budget(1): + oversized = self.route(facade) + if application: + # One whole item is returned alone rather than rejected or clipped. + self.assertEqual(oversized['content']['items'], first['content']['items']) + self.assertEqual(oversized['content']['next']['content'], {'offset': 1, 'limit': 8}) + with budget(1): + last = self.app.route(oversized['content']['next']) + self.assertEqual(first['content']['items'] + last['content']['items'], full['content']['items']) + self.assertNotIn('next', last['content']) with patch.object(agent_navigation, 'ROUTE_CONTENT_RESULT_BYTES', 1): rejected = self.route(facade) self.assertEqual(rejected['outcome'], 'unsupported') self.assertNotIn('content', rejected) + if not application: + self.assertEqual(oversized, rejected) # The explicit non-composed operation remains available. self.assertIn('reading_plan', facade.route({'snapshot': self.snapshot, 'facts': known_assertions()})) + def test_application_page_budget_default_and_host_configuration(self): + self.assertEqual(agent_navigation.ROUTE_PAGE_BYTES, 40 * 1024) + self.assertEqual(self.app._engine.route_page_bytes, agent_navigation.ROUTE_PAGE_BYTES) + # The default holds both fixture items; each returned page stays within it. + default = self.route(self.app) + self.assertEqual(len(default['content']['items']), 2) + self.assertLessEqual(len(json.dumps(default).encode('utf-8')), agent_navigation.ROUTE_PAGE_BYTES) + first = self.route(self.app, content={'limit': 1}) + configured = len(json.dumps(first).encode('utf-8')) + self.assertGreaterEqual(configured, agent_navigation.ROUTE_PAGE_MIN_BYTES) + with StandardsEngine.open_repository( + ROOT, purpose='application', store_path=fixture.PurposeProjectionTest.store_path, + route_page_bytes=configured) as engine: + self.assertEqual(engine.route_page_bytes, configured) + page = self.route(AgentToolFacade(engine, _contracts(ROOT))) + self.assertEqual(page, {**first, 'content': {**first['content'], 'next': { + **first['content']['next'], 'content': {'offset': 1, 'limit': 8}}}}) + # The same budget never shortens an authoring page. + with StandardsEngine.open_repository( + ROOT, purpose='authoring', store_path=fixture.PurposeProjectionTest.store_path, + route_page_bytes=agent_navigation.ROUTE_PAGE_MIN_BYTES) as engine: + self.assertEqual(self.route(AgentToolFacade(engine, _contracts(ROOT))), self.route(self.author)) + def test_schema_whole_numbers_normalize_before_slicing(self): for facade in (self.author, self.app): for offset in (0, 1): @@ -184,3 +238,46 @@ def read(*args, **kwargs): value = self.route(self.author) self.assertEqual(value['code'], 'FIXTURE.READ_UNAVAILABLE') self.assertNotIn('content', value) + + +class RoutePageBudgetOptionTest(unittest.TestCase): + def test_budget_range_is_closed_and_whole(self): + admit = agent_navigation.admit_route_page_bytes + self.assertEqual(admit(None), agent_navigation.ROUTE_PAGE_BYTES) + for value in (agent_navigation.ROUTE_PAGE_MIN_BYTES, 50_000, agent_navigation.ROUTE_CONTENT_RESULT_BYTES): + self.assertEqual(admit(value), value) + for value in (0, -1, agent_navigation.ROUTE_PAGE_MIN_BYTES - 1, + agent_navigation.ROUTE_CONTENT_RESULT_BYTES + 1, True, 40960.0, '40960'): + with self.subTest(value=value), self.assertRaises(ValueError): + admit(value) + with self.assertRaises(ValueError): + MCPServer(ROOT, purpose='application', route_page_bytes=1) + + def test_server_passes_its_budget_to_every_call(self): + for configured in (None, 50_000): + server = MCPServer(ROOT, purpose='application', route_page_bytes=configured) + self.addCleanup(server.close) + initialize(server) + with patch.object(AgentToolFacade, 'open_repository') as opened: + opened.return_value.__enter__.return_value.route.return_value = {'kind': 'fixture'} + server.dispatch(request('tools/call', {'name': 'route', 'arguments': {'facts': {}}})) + self.assertEqual(opened.call_args.kwargs['route_page_bytes'], + configured or agent_navigation.ROUTE_PAGE_BYTES) + + def test_launch_option_is_validated_before_serving(self): + def launch(*arguments): + return subprocess.run( + [sys.executable, '-P', '-m', 'tools.standards_engine.standards_engine.mcp', '--no-observe', + '--repo-root', str(ROOT), *arguments], + input='', text=True, capture_output=True, env={**os.environ, 'PYTHONPATH': str(ROOT)}, timeout=90) + accepted = launch('--purpose', 'application', '--route-page-bytes', '50000') + self.assertEqual((accepted.returncode, accepted.stdout, accepted.stderr), (0, '', '')) + for purpose, value, reason in (('application', '100', 'from 8192 to 2097152'), + ('application', '9999999', 'from 8192 to 2097152'), + ('application', 'large', 'invalid int value'), + ('authoring', '50000', 'applies to the application purpose')): + with self.subTest(purpose=purpose, value=value): + refused = launch('--purpose', purpose, '--route-page-bytes', value) + self.assertEqual(refused.returncode, 2) + self.assertEqual(refused.stdout, '') + self.assertIn(reason, refused.stderr) diff --git a/tools/standards_engine/tests/test_routing_fact_transport.py b/tools/standards_engine/tests/test_routing_fact_transport.py index faaefbf6..a1419766 100644 --- a/tools/standards_engine/tests/test_routing_fact_transport.py +++ b/tools/standards_engine/tests/test_routing_fact_transport.py @@ -1,4 +1,4 @@ -"""Snapshot-bound focused assertions, qualification and real cold stdio responses.""" +"""Snapshot-bound focused assertions, review labels and real cold stdio responses.""" from __future__ import annotations from copy import deepcopy @@ -115,11 +115,21 @@ def test_type_resolution_uses_the_selected_durable_snapshot_not_ambient_files(se invalid=self.route(purpose,{'probe':['x']}) self.assertEqual(invalid['input_feedback']['issues'][0]['message'],'boolean fact value is invalid') - def test_qualification_precedes_vocabulary_interpretation(self): - with patch.object(routing_inputs,'bind_facts',side_effect=AssertionError('private vocabulary')): - result=self.route('application',{'PRIVATE_FIELD':'PRIVATE_VALUE'},snapshot='unqualified') - self.assertEqual(result['code'],'APPLICATION.CONTENT_UNAVAILABLE') - self.assertNotIn('input_feedback',result) + def test_unapproved_router_vocabulary_is_interpreted_and_its_route_labelled(self): + app=self.facades['application'] + approved=self.route('application',{'probe':True},content={'limit':1}) + routed=self.route('application',{'probe':True},snapshot='unqualified',content={'limit':1}) + self.assertEqual(routed['kind'],'application-route-result',routed) + self.assertEqual({entry['review_state'] for entry in approved['reading_plan']},{'current'}) + self.assertEqual(routed['reading_plan'],[{**entry,'review_state':'not-reviewed'} for entry in approved['reading_plan']]) + self.assertEqual(routed['content']['items'][0]['review_state'],'not-reviewed') + self.assertEqual(routed['content']['items'][0]['content'],approved['content']['items'][0]['content']) + self.assertEqual(app.routing_facts({'snapshot':self.snapshots['unqualified']})['facts'], + app.routing_facts({'snapshot':self.snapshots['boolean']})['facts']) + # A wrong fact name is ordinary invalid input, not a publication state. + result=self.route('application',{'PRIVATE_FIELD':'PRIVATE_VALUE'},snapshot='unqualified') + self.assertEqual(result['code'],'APPLICATION.INPUT_INVALID') + self.assertIn('input_feedback',result) self.assertNotIn('PRIVATE',json.dumps(result)) def test_single_bind_and_verified_load_per_focused_content_call(self): @@ -210,7 +220,7 @@ def test_input_discovery_and_output_schema_contain_only_the_new_focused_shape(se self.assertIn('RoutingFactAssertion',records) self.assertNotIn('FactValue',records) self.assertNotIn('FactSet',records) - self.assertEqual(page['interface_version'],48) + self.assertEqual(page['interface_version'],self.interface.interface.interface_schema_version) def test_schema_digest_guard_and_final_lifecycle_checks_still_apply(self): author=self.engines['authoring'] diff --git a/tools/standards_engine/tests/test_runtime_identity.py b/tools/standards_engine/tests/test_runtime_identity.py index 0a03ecef..43bb6b49 100644 --- a/tools/standards_engine/tests/test_runtime_identity.py +++ b/tools/standards_engine/tests/test_runtime_identity.py @@ -32,7 +32,8 @@ def test_catalog_and_response_metadata_bind_one_running_process(self): for result in (initial, catalog, response): self.assertEqual(result['_meta']['standards-engine/runtime']['instance_id'], value['instance_id']) self.assertEqual(result['_meta']['standards-engine/runtime']['catalog_digest'], value['catalog_digest']) - self.assertEqual(value['interface_version'], 48) + self.assertEqual(value['interface_version'], + AgentToolFacade.load_interface(ROOT).interface.interface_schema_version) self.assertEqual(value['installation_state'], 'current') self.assertEqual(value['action'], 'reuse') self.assertFalse(initial['capabilities']['tools']['listChanged']) diff --git a/tools/standards_engine/tests/test_schema_presentation.py b/tools/standards_engine/tests/test_schema_presentation.py index 4da1b27d..3c2fedab 100644 --- a/tools/standards_engine/tests/test_schema_presentation.py +++ b/tools/standards_engine/tests/test_schema_presentation.py @@ -83,7 +83,7 @@ def test_runtime_catalog_identity_tracks_output_delivery_without_store_access(se for server in servers: initialize(server) value = server.dispatch(request('tools/call', {'name': 'runtime_info', 'arguments': {}}))['result']['structuredContent'] - self.assertEqual(value['interface_version'], 48) + self.assertEqual(value['interface_version'], self.interface.interface.interface_schema_version) digests.append(value['catalog_digest']) self.assertNotEqual(*digests) other = servers[1].dispatch(request('tools/call', {'name': 'runtime_info', 'arguments': {'expected_catalog': digests[0]}}))['result']['structuredContent'] diff --git a/tools/standards_engine/tests/test_supporting_workflow.py b/tools/standards_engine/tests/test_supporting_workflow.py index 581ecbf5..5bd1c350 100644 --- a/tools/standards_engine/tests/test_supporting_workflow.py +++ b/tools/standards_engine/tests/test_supporting_workflow.py @@ -113,9 +113,11 @@ def test_coordinated_publication_and_provenance_only_revision(self): # accepted corpus, and publish it without an application approval. unexposed = self.author.read({"snapshot": published_snapshot, "target": UNEXPOSED, "detail": "full"}) self.assertIn(PUBLIC, unexposed["content"], unexposed) - empty = self.app.read({"snapshot": published_snapshot, "target": UNEXPOSED}) - self.assertEqual(empty["code"], "APPLICATION.CONTENT_UNAVAILABLE", empty) - self.assertEqual(self.app.read({"snapshot": published_snapshot, "target": REFERENCE})["kind"], "application-read-result") + labelled = self.app.read({"snapshot": published_snapshot, "target": UNEXPOSED}) + self.assertEqual((labelled["kind"], labelled["review_state"]), ("application-read-result", "not-reviewed"), labelled) + self.assertEqual(labelled["content"], unexposed["content"]) + self.assertEqual(first["review_state"], "current") + self.assertEqual(self.app.read({"snapshot": published_snapshot, "target": REFERENCE})["review_state"], "current") for aid in aids: exposed = self.app.read({"snapshot": published_snapshot, "target": aid["canonical_id"]}) self.assertEqual(exposed["kind"], "application-read-result", exposed) @@ -140,4 +142,4 @@ def test_coordinated_publication_and_provenance_only_revision(self): self.assertEqual(current["record"]["rationale"], PRIVATE + "_REVISED") self.assertNotEqual(current["authority"], old_snapshot) self.assertEqual(self.app.read({"snapshot": current["authority"], "target": RULE})["content"], first["content"]) - self.assertEqual(self.app.read({"snapshot": current["authority"], "target": REASON})["kind"], "application-rejected-result") + self.assertEqual(self.app.read({"snapshot": current["authority"], "target": REASON})["code"], "APPLICATION.UNKNOWN_TARGET")