diff --git a/docs/plans/README.md b/docs/plans/README.md index 22df5704..f511cffd 100644 --- a/docs/plans/README.md +++ b/docs/plans/README.md @@ -1,8 +1,11 @@ # Active Repository Work [Standards Library Effectiveness Restructure](standards-library-effectiveness/plan.md) -is the explicitly active plan. Remaining work includes manual semantic-ownership -reviews D001–D010, downstream pilots, migration publication, and final acceptance. +remains active for manual semantic-ownership reviews D001–D010, downstream pilots, +migration publication, and final acceptance. [Authoring Publication and Evidence +Clarity](authoring-publication-evidence/plan.md) is also active, beginning with its +A1 publication-observation and early-evidence slice. These plans own separate +objectives; neither changes the other's acceptance state. - [Current plan and next slice](standards-library-effectiveness/plan.md) - [Execution ledger](standards-library-effectiveness/execution-ledger.md) @@ -13,6 +16,16 @@ Completed prerequisites do not close the parent objective. See the [archive](../archive/README.md) for accepted and superseded plans, and the [decision index](../decisions/README.md) for current architecture. +## Authoring Publication and Evidence Clarity + +[Authoring Publication and Evidence Clarity](authoring-publication-evidence/plan.md) +owns publication receipts, fresh checkout observations, early evidence failures, +explicit evidence binding, guarded reconciliation, and focused blocker/reuse +explanations. A1 implementation is complete and in final verification; later +milestones remain Planned with their separate gates. Begin A2 only after A1 is +accepted and merged to `main`. The plan preserves existing publication +authorization and records each acceptance claim at its current evidence state. + ## Accepted Agent Interface Work [Standards Agent Interface](standards-agent-interface/plan.md) delivers focused diff --git a/docs/plans/authoring-publication-evidence/execution-ledger.md b/docs/plans/authoring-publication-evidence/execution-ledger.md new file mode 100644 index 00000000..36b6270e --- /dev/null +++ b/docs/plans/authoring-publication-evidence/execution-ledger.md @@ -0,0 +1,324 @@ +# Authoring Publication and Evidence Clarity — execution ledger + +## 2026-09-29 — review and planning admission + +The user requested review of current Coding-Standards code and a standards-aligned +implementation plan after sharing a standards-authoring agent's experience. +No production implementation, configuration change, canonical standards publication, +remote push or acceptance update was authorized or performed by this planning task. + +GitHub main resolved to `149ba317e9397519bc181a048ecf76aef129a69c`, tree +`fdd40edc1eea85398e97b740a595a42631614d0b`. The exact Actions bundle was verified and +checked out in an owned review workspace. It has a local main ref for existing test +fixtures; that is not a remote ref mutation. The current scope inspected publication, +coverage/evidence, workflow composition, exposure, consumers and governing guidance. + +The current Router executed with explicit planning/review/public-contract/persistence +facts and selected 25 standards without unresolved questions. Exact texts were read +through the local facade into a disposable store. No current external MCP registration +or original authoring-session private handles was accessed. The historical attached +source reviews were not relabeled as reviews of this candidate. + +Actual-facade fixture observations reproduced four reported mechanisms. The code +itself remained unchanged. Two initial fixture drafts had lookup/type errors; one +publication-follow-up probe selected an already used evidence directory. Corrected +scripts used fresh owned fixtures and recorded the deciding outputs. Original draft +errors remain separate from product findings. + +The existing native retained-decision helper successfully reused one unaffected +real successor disposition in memory without publishing a new Analysis. A Git +two-tree feasibility trial synchronized only publication work while preserving user +staged/unstaged/untracked content; a conflicting-path trial refused and preserved +state. Neither is a production reconciliation or evidence-binding implementation. + +Selected tests: 22 Engine + 125 Analysis + 41 Git executions; 187 passed, one +permission-dependent skip. Local complete structure: 73/73 suites, 121 checks. +Current hosted source CI failed in the two documented fixture-dependent Engine +entries; it is not relabeled green. Source checkout stayed clean. + +Plan is Planned; next implementation admission is `start` against +`docs/plans/authoring-publication-evidence/plan.md`. Exactly one next slice is A1. +All objective acceptance claims remain pending. Standards/composed-design validation +and artifact integrity are planning evidence only. + +## 2026-09-29 — A1 implementation admission + +The user admitted implementation with operation `start` against the canonical +`docs/plans/authoring-publication-evidence/plan.md` path. The implementation branch +is `implementation/authoring-publication-evidence-a1`, created at accepted +`149ba317e9397519bc181a048ecf76aef129a69c`, matching local `origin/main` at +admission. Work is isolated at `/tmp/cs-authoring-publication-evidence-a1`; the +pre-existing dirty `main` worktree was not carried into this branch or modified. + +The archive manifest was checked before copying only the five files in this plan's +directory. A1 is Active; all ten objective claims and A1 gates remain pending until +their exact candidate evidence is produced. No implementation or acceptance claim +is inferred from the archive's feasibility probes. + +### Writing assignment — B0 supporting-workflow fixture + +- Parent milestone: A1. +- Writer: GPT-6.1 Sol medium, branch + `implementation/authoring-publication-evidence-a1-b0-fixture`, worktree + `/tmp/cs-a1-b0-fixture`. +- Starting revision: `149ba317e9397519bc181a048ecf76aef129a69c`. +- Primary write set: `tools/standards_engine/tests/test_supporting_workflow.py`. +- Permitted adjacent file: `tools/standards_engine/tests/test_process_reuse.py` + only if required to keep its direct cache-enabled call valid. +- Shared/forbidden files: production code, canonical/generated contracts, + generated suite inputs, plan status, and every other test file. +- Required evidence: both direct and cache-enabled supporting-workflow cases keep + positive exposed-content and negative unexposed-content assertions without + relying on the real `topic.security` exposure state; run the focused tests when + the locked Python environment is available and report exact commands/results. +- Handoff requirement for the writer: proposed diff and evidence to the integration + owner for review; no writer-owned commit or merge. + +### B0 supporting fixture result + +The writer handed off the isolated diff without committing. The integration owner +reviewed it, confirmed the only write was the permitted supporting-workflow test, +and ran the direct and warm-cache fixture cases. Both passed (`2 tests`, `81.5s`) +using the locked Python 3.12 environment. The primary author then committed the +accepted patch as `9e7f88f5 test(standards): own unexposed publication fixture` +and merged it into A1 with `e1e72671 merge: observe publication checkout` after +the branch had advanced; `test_process_reuse.py` did not need an edit. The writer +did not invoke the Standards Engine MCP. The A1 plan remains Active and its claims +and gates remain pending. + +## 2026-09-29 — A1 implementation result + +A1 was implemented on the admitted isolated branch at `/tmp/cs-authoring-publication-evidence-a1`. +The original dirty main checkout remains on `149ba317` with its existing staged, +unstaged, and untracked changes; no A1 files were committed there. Implementation +and integration commits are authored as MrScripty. The current source candidate is +`20261782`; the A1 contract edition is interface 46, request contract 6, and result +projection 8. Generated contracts, catalogs, examples, and affected fixtures are +updated together. Application and readiness persistence schemas remain unchanged. + +The A1 source now separates the durable publication receipt from fresh target and +checkout/index observations on apply, recovery, and later status. Observation stays +read-only, treats conflicted and unsupported index layouts explicitly, pins and +revalidates checkout and administrative directory identities, and returns owned +`unavailable` failures when descriptor allocation or cancellation interrupts the +observation. Evidence destination preparation runs before readiness and again at +the final boundary. Authoring analysis failures retain bounded safe legacy +`path`/`field`/`observed` details and phase/reference/digest/source context; the +application purpose continues to redact them. A1 adds a real MCP subprocess read +of applied status after restart. No A2 evidence-binding or A3 checkout-reconciliation +write was added. + +The B0 fixture now owns its unexposed standard and preserves the accepted Security +exposure. A1 satisfies A-C1 with Git/SQLite and replacement-process evidence. +A-C2 remains pending for A2's bound-reference matrix; A1 covers the existing +repository-content@1 acquisition path and final revalidation. + +### Independent reviews + +- GPT-6 Astra Medium completed the composed architecture review, read-only. It + identified observer race and cancellation cleanup gaps during integration; both + were corrected and its final follow-up found no remaining architecture or scope + findings. +- GPT-6 Astra Medium completed the Standards review. It identified the lost + independent-store persistence assertion and untyped descriptor-allocation + failures. The test now covers both independent-store reconstruction and same-store + restart, the allocation errors are typed, and the reviewer found no remaining + findings on follow-up. +- GPT-6 Luna High completed the Spec/reference review. The safe legacy diagnostic + projection and interface 45-to-46 consumer/persistence dispositions were added; + its follow-up found no remaining gap on those points. +- The requested Passeur MCP review was not submitted. Current Pumas status is bound + to Pumas-Library and Tuldok status names an unrelated project with service state + `not_checked`; neither server is bound to this repository. No review request was + sent to the wrong project. A Passeur security/lifecycle review remains pending. + +### Validation + +- `tools.repository_git.tests.test_repository`: 31 passed in 2.7 seconds, including + race substitution, typed descriptor exhaustion, and cancellation cleanup. +- `tools.standards_engine.tests.test_analysis`: 21 passed in 77.2 seconds. +- A1 acceptance modules (`test_coverage_publication`, `test_agent_workflow`, + `test_publication_recovery`, `test_registration_contract`, and + `test_supporting_workflow`): 30 passed in 204.0 seconds. +- Direct and warm-cache B0 fixture cases: 2 passed in 91.2 seconds. +- Exact-candidate `verify_repository(refresh_verification_inputs=False)`: 73 + suites and 121 checks passed. The owner-generated suite input manifest is current. +- `git diff --check` passed. The exact-candidate hosted CI was not run. + +Standards Engine MCP usability observations are captured separately in +[mcp-usability-feedback.md](reports/mcp-usability-feedback.md). It confirmed the +live process at interface 45, but was left running against the dirty main checkout; +it was not pointed at or restarted with the A1 worktree. A broad route response was +truncated and targeted `read_many` calls were useful. No remote push or hosted PR was +created; a ready-to-post PR draft is recorded separately. + +## 2026-09-29 — A1 PR and final-review repair + +Opened draft PR [#2](https://github.com/MrScripty/Coding-Standards/pull/2) from +`implementation/authoring-publication-evidence-a1` to `main`. Its base is accepted +`149ba317e9397519bc181a048ecf76aef129a69c`; initial published head was +`78a69fbb4adaee386baf1c8503d337c42bbd5db4`. The PR remains draft. + +GPT-6 Astra Medium's read-only final review of that head found that +`_application_publication_projection` read the canonical target branch without +`local_only=True`, and that the plan advanced to A2 before A1's hosted checks, +independent review, and main integration. GPT-6 Luna High confirmed that no test +asserted the target read's local-only option or unavailable projection shape. + +GPT-6.1 Sol medium was assigned the exact write set +`engine.py` and `test_analysis.py` in a separate worktree, starting from +`78a69fbb`. It updated the target observation to use a local-only read and added +a regression for the exact keyword, candidate-tree and checkout reads, and bounded +unavailable output. It also updated the repeated-recovery mock expectation. The +focused regression and adjacent recovery case passed (2 tests, 9.977 seconds). +The worker commit `7d8904a9d4c3cc1528d0e0e0fe388d5fd2882b8c` is authored by +MrScripty and was integrated into A1 by fast-forward; no cherry-pick or history +rewrite was used. + +The first full post-repair run (77 tests) exposed stale `suite-inputs.json` +digests for `engine.py` in test-owned Git snapshots. The integration owner +refreshed the generated manifest on A1; local repository verification then passed +(73 suites, 121 checks). The full post-refresh acceptance rerun is pending. The +source fix has not yet been pushed to PR #2. Hosted run `36646667390` and its +CodeRabbit status are for the older `78a69fbb` head; the workflow was in progress +and does not qualify the current source candidate. + +The plan and plan index now keep A1 in `Verifying` and defer A2 implementation +until A1 is accepted and merged to `main`. At the time of this entry, a second read-only candidate review and Passeur +security/lifecycle review remained pending. The available +Passeur service is bound to Pumas-Library, so no Coding-Standards review was +submitted through the wrong repository context. + + +### Local acceptance before the Sol High final review (superseded) + +The committed source candidate `033dde3623a6bd917d3def5c75b9c748d6cd4f27` +passed the seven-module A1 acceptance command in the hash-locked offline Python +3.12 environment: 83 tests passed in 264.677 seconds. The modules were +`tools.repository_git.tests.test_repository`, +`tools.standards_engine.tests.test_analysis`, +`tools.standards_engine.tests.test_coverage_publication`, +`tools.standards_engine.tests.test_agent_workflow`, +`tools.standards_engine.tests.test_publication_recovery`, +`tools.standards_engine.tests.test_registration_contract`, and +`tools.standards_engine.tests.test_supporting_workflow`. The command includes +local test-owned Git repositories and mocked boundary/failure cases; it does not +qualify live remote or hosted-service behavior. `verify_repository` with +`refresh_verification_inputs=false` passed 73 suites and 121 checks on the same +source candidate. `git diff --check` passed. + +GPT-6 Astra Medium completed a read-only architecture review of exact candidate +`033dde3623a6bd917d3def5c75b9c748d6cd4f27` against accepted base +`149ba317e9397519bc181a048ecf76aef129a69c` and found no new actionable findings. +It confirmed that commit `7d8904a9` resolves the local-only target observation +finding and the plan now defers A2 until accepted A1 integration. The review notes +that the regression is a mocked boundary assertion and does not qualify real +partial-clone behavior. + +At this point, PR #2 still publishes the earlier `78a69fbb` head; the updated A1 +candidate has passed local acceptance and is awaiting a normal fast-forward push. +Exact-candidate hosted checks are still pending. The PR remains draft, the Passeur +security/lifecycle review remains unavailable because its service is bound to +Pumas-Library, and maintainer-authorized merge to `main` remains outstanding. + + +## 2026-09-29 — Sol High final review repairs + +GPT-6.1 Sol high's read-only review of `f676cfaf` found two A1 acceptance gaps: +phase-specific authoring diagnostics copied canonical evidence strings without +field-specific size/shape bounds; and readiness preflight accepted evidence from +Engine receipts, the attestation registry, or suite-input manifest that coverage +publication would replace. Final validation prevented unsafe publication, but the +preflight did not reject the mismatch early. + +GPT-6.1 Sol medium implemented both repairs in worker commit +`01bb2d031028858e6c6d53bbb2e8d37c453fb972`, starting from exact `f676cfaf`, with +write set `engine.py`, `test_analysis.py`, and `test_coverage_publication.py`. +The primary owner reviewed the diff and integrated it into A1 with a fast-forward. +Sol High's read-only follow-up found both findings closed and no new actionable +issue. Diagnostics now enforce field-specific bounds and shapes; preflight rejects +evidence and exclusions that reference the selected receipt, registry, or manifest +paths before readiness or candidate publication proceeds. Existing final +validation remains. + +The worker's focused publication lifecycle regression passed (1 test, 57.058 +seconds), and its focused diagnostic regression passed. Its first five-module run +reported 69 passes and two failures caused only by stale suite-input digests for +the edited `engine.py`; it did not modify generated files. The primary owner +refreshed and committed those declared digests as `fab920f4`. + +On committed candidate `fab920f4`, the complete seven-module A1 acceptance command +passed **84 tests in 274.047 seconds** in the locked offline Python 3.12 +environment. `verify_repository(refresh_verification_inputs=false)` passed 73 +suites and 121 checks; the preceding manifest refresh also passed those 73 suites +and 121 checks. `git diff --check` passed. The final local gate is satisfied for +this candidate. Exact-head hosted CI and the Passeur review remain pending; the +published PR head still needs the repair pushed and the draft body updated. Main +integration remains maintainer-controlled, so the plan stays `Verifying` and A2 +has not started. + +## 2026-09-29 — current-interface consumer assertions + +The exact hosted workflow for an earlier candidate failed nine assertions across +five test modules because they expected interface 45 from the current interface-46 +Engine. The failures inspect the installed Engine's runtime identity, discovery +metadata, or instructions; they are not legacy client-v45 compatibility fixtures. +The review confirmed that legacy upgrade dispositions and surrounding lifecycle +and disclosure assertions should remain unchanged. + +GPT-6.1 Sol high performed this read-only classification against the five current +test modules. GPT-6.1 Sol medium updated only the five corresponding +installed-interface expectations to 46 in commit +`b0d36338f5799a30e82ed8755e4560c0b27007be`, then ran those modules in the locked +offline Python 3.12 environment: **24 tests passed in 165.995 seconds**. The +integration owner reviewed the exact five-line diff and fast-forwarded that commit +into the isolated A1 branch. + +On the integrated candidate, the seven existing A1 modules plus those five +consumer modules passed together: **108 tests in 470.795 seconds**. Both +`verify_repository` with `refresh_verification_inputs=true` and the subsequent +read-only verification passed **73 suites and 121 checks**. Refresh produced no +manifest delta. `tools/standards_verifier/verify.py --complete` also passed all 73 +suites with zero failures or blocked checks. + +Hosted run `36648831399` for an earlier synthetic merge ref failed on those stale +interface assertions after 612 tests; it did not reach `verify.py --complete`. +Exact PR-head run `36651259589` targeted `95b13802` and later completed with the +same stale interface-45 expectations. Neither run qualifies the corrected +candidate. A fresh exact-head hosted run is required after this candidate is +published. The PR stays draft, the plan stays `Verifying`, A-C10's Passeur review +is outstanding because the available service remains bound to Pumas-Library, and +A2 remains deferred until A1 acceptance and main integration. + +## 2026-09-29 — preserve valid evidence paths in authoring diagnostics + +GPT-6.1 Sol high's read-only final architecture review found that the bounded +authoring projection dropped supported `repository-content@1` paths containing +spaces, printable Unicode, or a dot-prefixed name. These names are valid under the +repository-relative path resolver; omitting them lost the exact evidence identity +from an authoring failure. The application-purpose projection remains redacted. + +GPT-6.1 Sol medium fixed only `engine.py` and `test_analysis.py` in isolated worker +commit `e6da2e5fa2ba4b32ae9edb5cb49e4b2ed6ddf2c3`. The bounded path case now admits +printable relative paths up to 1,024 characters and rejects control characters, +absolute/drive/backslash paths, empty/dot/traversal segments, and overlong values. +Tests cover spaces, Unicode, leading-dot names, invalid forms, strict ASCII fields, +and application-purpose redaction. Sol high's read-only follow-up confirmed the +finding closed and reported no other architecture issue. + +The first integration-owner rerun before committing generated suite-input digests +reported 15 failures and two errors, all from test-owned Git snapshots seeing a +stale `engine.py` digest. `verify_repository(refresh_verification_inputs=true)` +passed 73 suites and 121 checks and refreshed the declared `engine.py` and +`test_analysis.py` inputs; commit `ecbf25cdcd8218b44e68b6adb359c7efaeea765d` +records those generated hashes. On that exact source/manifest candidate, the +combined twelve-module A1 and interface-consumer command passed **108 tests in +427.181 seconds**. `verify_repository(refresh_verification_inputs=false)` passed +73 suites and 121 checks; `verify.py --complete` passed 73 suites with zero +failures or blocked checks; `git diff --check` passed. + +At the time of this entry, hosted run `36653728027` for preceding head `6921489c` +was still in progress. It predates this path fix and generated manifest update, so +it cannot qualify the current source. The next exact-head hosted result, Passeur +security/lifecycle review, and accepted main integration remain outstanding. A1 +stays `Verifying`; A2 remains deferred. diff --git a/docs/plans/authoring-publication-evidence/issues.md b/docs/plans/authoring-publication-evidence/issues.md new file mode 100644 index 00000000..09a8aeff --- /dev/null +++ b/docs/plans/authoring-publication-evidence/issues.md @@ -0,0 +1,23 @@ +# Authoring Publication and Evidence Clarity — issues + +These issues are new observations or explicit design gates. Existing accepted +refactors and historical external-review decisions remain unchanged. + +| ID | Type | Disposition and owner | +| --- | --- | --- | +| B0 | Baseline CI / fixture | Resolved in A1 with a test-owned unexposed standard and unchanged Security exposure. Direct and warm-cache fixture cases pass on the committed candidate; no hosted exact-candidate CI result is claimed. | +| F1 | Publication reporting | Resolved in A1: apply, recovery, and status expose durable receipt facts separately from read-only checkout/index observations. Checkout reconciliation writes remain A3. | +| F2 | Evidence phase binding | Resolved for repository-content@1 in A1: side-effect-free preflight catches destination mismatch before readiness, while final apply repeats the check. A2 adds explicitly bound immutable artifacts. | +| F3 | Diagnostics | Resolved in A1: the evidence producer reports phase/reference/digest/source context; legacy path/field/observed details are bounded for authoring and omitted for application purpose. | +| F4 | Focused reuse | One unchanged obligation requires a new submission because focused revise omits prior Analysis reuse. Existing helper passed the real successor in memory. A4 composes it; final readiness is never copied. | +| F5 | Exposure explanation | Confirmed Router needs-review is hidden by generic preview rejection. A4 retains denial and exposes only authoring-permitted blocker context. | +| G1 | Evidence carrier proof | Proposed self-contained bundle keeps current four-field repository-content carrier. A2 must prove original-content provenance, exact validation, authorized export and cold receipt use before expansion. If incompatible, own a versioned redesign, not a source-label workaround. | +| G2 | Reconciliation write ownership | Two-tree trials cover ordinary carry-forward and conflict refusal only. A3 must prove supported layouts, stale/partial outcomes and explicit cooperative ownership; no atomic multi-resource claim is made. | +| G3 | Original run / model evidence | Original session handles/transcript and current live model are not available. Current-code reproductions are not a replay of that session. A5 owns a newly authorized comparable fixture run. | +| G4 | Versions and old history | Actual persisted records constrain changes. Keep their source meaning and explicit version support; new bundle/intent kinds do not justify blanket migration or old-handle reset. | +| D1 | Deferred UI/response ideas | No new short-ID resolver, larger eager catalog, universal schemas/examples tool, or automatic final-approval transfer. Consider only after measured remaining friction and a new admission. | + +No acceptance claim is satisfied solely by the planning probes. No unrelated source +repair or accepted plan is included. New findings during implementation are assigned +to the existing owner/write set unless they alter scope, authority or retained +meaning. diff --git a/docs/plans/authoring-publication-evidence/plan.md b/docs/plans/authoring-publication-evidence/plan.md new file mode 100644 index 00000000..eed02c63 --- /dev/null +++ b/docs/plans/authoring-publication-evidence/plan.md @@ -0,0 +1,593 @@ +# Authoring Publication and Evidence Clarity + +**Plan status:** `Active` + +**Current phase:** A1 implementation is complete; final acceptance and main-targeted PR review are in progress. + +**Next slice:** Complete A1's exact-candidate hosted checks and required independent review. Begin A2 only after A1 is accepted and merged to `main`. + +**Acceptance status:** `pending` + +**Composed-design review:** `applicable`; see [Simplicity and Ownership Review](#simplicity-and-ownership-review). + +**Execution ledger:** [execution-ledger.md](execution-ledger.md) + +**Issues:** [issues.md](issues.md) + +This is a new scope motivated by the supplied agent authoring report. It does not +reopen the accepted refactoring or routing-fact work, nor declare unrelated pending +packaging/test-strengthening acceptance complete. The source review and plan were +delivered as a planning-only archive; the current user request explicitly admits +implementation with operation `start` against this canonical plan path. The exact +starting revision is `149ba317e9397519bc181a048ecf76aef129a69c`, which matches +`origin/main`. A1 is owned by branch +`implementation/authoring-publication-evidence-a1` in task worktree +`/tmp/cs-authoring-publication-evidence-a1`. The original user worktree's staged, +unstaged, and untracked changes remain outside this branch. + +## Objective + +Enable an authorized standards author to understand exactly what was published, +which bytes each evidence reference supports, and which next action is safe. A +small authoring change should not reach nominal readiness with an already-detectable +destination-evidence mismatch, nor report publication without distinguishing the +canonical ref from the selected checkout/index. Preserve real authorization, +current-state checks, immutable revision binding, atomic co-edits, and portable +review receipts. Reuse existing mechanisms instead of adding another approval +system, mutable task session, generic evidence framework, or short-ID registry. + +## Reviewed Source and Evidence + +Review baseline: `149ba317e9397519bc181a048ecf76aef129a69c`, tree +`fdd40edc1eea85398e97b740a595a42631614d0b`, Engine interface **45**, request contract +**6**, result projection **7**. The exact Actions source artifact is `11036434347` +from run `36574954850`, archive SHA-256 +`34d36acefcb3b9c4be1bf096797bbd3c111f893f2c8bb2ca8c0e2d00be802f0f`. +Its latest commit is an Engine-generated standards publication, not a runtime-code +change. Its old-looking deterministic Git timestamp is not evidence that it is an +old branch tip. The original agent session's private handles/transcript were not +supplied; the review reproduces mechanisms on this pinned code, not that exact run. + +[Source review](reports/code-review.md) contains locations, actual results and +limitations. [Consumer inventory](reports/source-consumers.md) maps the public, +authorization, persistence, Git and presentation owners. Four actual-facade probes +reproduced the reported publication/index mismatch, late candidate-evidence failure, +generic exposure rejection and avoidable renewed Analysis work. In-memory reuse +and real Git two-tree trials establish bounded feasibility, not implementation. + +The historical baseline CI run failed in two cases of the same supporting-workflow +scenario because its negative assertion depended on accepted Security exposure. +A1 replaced that assumption with a test-owned unexposed standard, without changing +Security exposure. The direct and warm-cache cases pass on the A1 candidate. No +hosted exact-candidate CI run is claimed. See issue B0. + +## Objective Acceptance + +| ID | Observable criterion | Kind | Environment | Mode | Status | Evidence | +| --- | --- | --- | --- | --- | --- | --- | +| A-C1 | Apply, recovery and later status distinguish durable publication identity from a fresh checkout/index observation, including unknown outcomes. | contract + integration | real Git and SQLite, replacement processes | automated | satisfied | A1 publication/recovery integration, including a new MCP process reading the retained applied result | +| A-C2 | Already-incompatible evidence is identified before readiness, with exact phase/reference/digest/source context; later changes still reject at the final boundary. | negative + lifecycle | real authority/evidence, both wire entrypoints | automated | pending | A1 covers repository-content@1; A2 must extend the matrix to bound references and both entrypoints | +| A-C3 | Explicit baseline, candidate and imported-local acquisitions retain exact bytes and provenance, never switch sources silently, and remain distinct from the decision's subject and authority. | contract + persistence | real Git, snapshot/projection and bounded local inputs | automated | pending | A2 capture/export oracles | +| A-C4 | Published bound evidence and coverage remain verifiable in a cold clone without the original worktree, capture store or external file; genuine legacy evidence retains its original meaning. | retained-history | old producer/new consumer and new exported candidate | automated | pending | A2 legacy/new receipt fixtures | +| A-C5 | Explicit reconciliation preserves unrelated staged, unstaged and untracked work; overlaps, stale observations and partial failures have owned outcomes without republishing. | lifecycle + concurrency | supported Linux/Git, real index/files and injected interleavings | automated | pending | A3 reconciliation matrix | +| A-C6 | Authorized previews identify blocking exposure/prerequisite material; application-purpose callers still receive only permitted information. | purpose boundary | real candidate and private dependencies | automated | pending | A4 redaction/diagnostic cases | +| A-C7 | Focused successor Analysis reuses only independently revalidated applicable decisions and explains invalidations; old decisions/readiness are never relabeled as new approvals. | semantic + differential | real Analysis, source/evidence drift and authorization | automated | pending | A4 reuse matrix | +| A-C8 | Generated contracts, supported callers, bounded compact responses and task examples are coordinated; required locked CI passes against the integrated material. | integration | current supported hash-locked CI | automated | pending | A5 exact-candidate evidence | +| A-C9 | An actual authorized agent completes a bounded authoring change, understands evidence and publication, and uses explicit reconciliation without unexplained repair loops or a new mandatory discovery ritual. | user workflow | real supported client against disposable repository | observed | pending | A5 matched authoring task | +| A-C10 | Independent material review and acceptance-owner disposition establish scope, retained identities and completion of only this new plan. | review + acceptance | independent reviewer and acceptance owner | manual | pending | Final decision record | + +A fixture may use explicit test authorization but cannot establish editorial truth +or downstream quality. Observing a read-only review is not evidence that tests ran. +No production standards mutation is needed for qualification. Do not add mandatory +model runs to every intermediate patch; A-C9 is for the coherent final candidate. + +## Scope + +### In scope + +Authoring publication reporting, a narrowly explicit checkout reconciliation action, +baseline/candidate/imported evidence acquisition and durable binding, early +publication-evidence preflight, scoped failure detail, candidate exposure explanation, +validated successor Analysis reuse, and the directly affected schemas, consumers, +examples, retained-state tests and records. Each milestone includes its own necessary +verification. Fix the demonstrated current fixture assumption as a qualification +prerequisite, not as a reason to weaken exposure checks. + +### Out of scope + +Remote pushes, history rewrites, changing the canonical branch policy, automatic +reset/stash/clean/rebase, unattended merging of user edits, repairing arbitrary +worktrees, new provider integrations or network evidence fetch, secret scanning, +global acceptance automation, an independent reviewer service, a new fact engine, +cache expansion, typed-edit conversion, eagerly embedding all schemas, replacing +exact handles with short request IDs, or broader downstream pilots. No existing +review/authorization requirement is dropped because a change is small or metadata. + +## Binding Decisions + +### D1 — Publication and checkout state are independent facts + +Keep canonical publication's existing meaning: a verified candidate is imported, +the expected target ref is advanced, and its selected application outcome is recorded. +Do not secretly broaden apply into checkout mutation. Extend the existing native +apply/recovery results and focused workflow projection with one publication receipt: +application identity, exact candidate commit/tree, target ref, expected predecessor, +and durable publication state. These are already stored or derivable from the +selected ProposalApplication; they do not need another receipt registry. + +Include an explicitly fresh checkout observation: selected worktree/HEAD binding, +index tree or exact index observation, whether publication paths still represent +the predecessor, safe mismatch counts, and observation status. Keep `not-observed`, +`unavailable`, `not-target-checkout`, `current`, `needs-reconciliation` and `conflicted` +distinct. Exact wire discriminants are generated under the existing schema owner; +there is no single boolean `clean` standing in for these meanings. A checkout error +after durable publication must not disguise the publication as failed or advertise +apply as the next action. Historical publication success and a later diverged target +are also separate observations. + +`workflow_status` reconstructs the durable receipt after reconnecting and observes +current Git state again. It must not fabricate an original before-image for an old +application. New optional observation records are versioned separately if they must +persist; otherwise keep them ephemeral. Compact results include the commit/ref and +next action once; bounded detailed path lists belong in a selected detail page. +Never let a size limit hide a successful mutation or lose its application handle. + +### D2 — Early evidence preflight, with one shared publication interpretation + +Extract the evidence/destination assembly currently first exercised by +`_publish_coverage_into_candidate` into an owned, side-effect-free preparation +step shared by readiness/preflight and apply. It examines the exact logical +projection, coverage requirements and selected evidence. It does not publish a +Git ref, write readiness, grant apply authority, or pre-issue a publication approval. +Only after it succeeds may a new readiness claim be recorded. + +For existing `repository-content` version 1 references, preserve the actual +contract: live local authorization plus destination-compatible bytes for portable +coverage. Identify a changed, removed or uncommitted destination reference before +issuing readiness. Baseline evidence that cannot fulfill that destination contract +must be rejected with an actionable explanation or explicitly bound through D3; +never change its digest or source silently. Old readiness is not rewritten; apply +performs the new safety preflight while retaining its original immutable binding. + +Final apply still rechecks live capability/revocation, exact revision/head, evidence +where its contract requires a live observation, destination assembly, actual +candidate verification and expected-target publication. Preflight success is not +cached authority. Separate pure evidence preparation from final publication-grant +construction: a review request must not exercise `publish-coverage` merely to +obtain an early error. Candidate receipts depending on live authorization are +constructed and checked at their proper final boundary. + +### D3 — Explicit bound evidence, reusing the current reference carrier + +The selected first design is **Engine-bound, self-contained evidence artifacts**, +not a universal new provider ecosystem or an expanded EvidenceReference at every +existing use. Keep the four-field canonical EvidenceReference and request-local +evidence table. Add one bounded authoring acquisition operation, provisionally +`bind_evidence`, accepting a batch of explicit source selections and optional expected +source digests. Verify a supplied digest; otherwise return the digest of the exact +verified capture without requiring the caller to compute it first. It returns +reusable existing-format references plus provenance and an inspection handle. Use existing `inspect` for later observation rather than a +new family of evidence-list/query tools. + +Supported acquisitions: + +- **Baseline:** a named live snapshot and explicit path, or its exact recorded Git + revision when an explicitly requested file is outside the captured compiler + closure. Use the repository's verified object reader, not the checkout. Record + both selected snapshot identity and actual source revision/path. An unavailable + original object is unavailable, not permission to use current bytes. +- **Candidate:** an exact existing proposal-revision handle and path read from its + verified logical projection. Preserve proposal/revision and projected-material + identity. This is the source of evidence, not an assertion that it covers the + final publication commit. Final-generated receipts cannot be evidence for their + own identity; reject cycles/self-reference rather than invent a fixed point. +- **Imported local:** an explicitly selected bounded regular file under an + operator-authorized root. Reuse an existing configured repository-local root for + the initial deployment where adequate; supporting a separate root requires an + explicit narrow composition setting and authorization, not arbitrary filesystem + access. Record original locator as caller provenance, byte digest and capture + identity. No URL fetching, shell execution, directory crawling or silent "working + tree equals candidate" inference occurs. + +An immutable bundle contains version, validated source descriptor, exact original +content bytes and digest, and any caller-reported external subject/producer metadata +marked as reported rather than verified. One canonical serialization owns the bundle; +its digest determines a reserved, collision-checked repository evidence path. Return +an ordinary `repository-content@1` reference to those **bundle bytes**, explicitly +labelled as such; retain the original content digest separately. Do not claim that +the bundle digest is the raw source digest. Source/provenance changes change the +bundle identity even when raw bytes happen to match. + +Use one Engine-owned evidence-binding module and the existing snapshot aggregate/ +content lifecycle for these bounded captures. No independent database or global +registry is needed. Preserve retention dependencies and failure cleanup; do not +expose a usable binding whose bytes were never admitted. Select and document named +per-item, batch and retained-material limits during the A2 vertical proof, using the +existing source/object limits where suitable; reject overflows without truncation +and test boundaries with small injected limits. Acquisition observes and binds material; it does not grant a decision, review or publication. + +Adapt the local evidence resolver through explicit bound records supplied by its +composition owner. For a bound reference, it resolves the recorded immutable +bundle, checks its identity/content, and authorizes each actual subject/action +freshly. It must not consult a same-named worktree file or guess an alternative +provider. Legacy raw references remain on their existing resolver. Separate the +resolver from authorization policy; Engine must not import its facade to resolve +source, and the new module must not become a second semantic trust validator. + +Include exactly the bound artifacts reachable from a proposal's purpose/edits, +Analysis decisions, coverage claims and review decisions in the generated candidate. +Collect through typed owned fields, not recursive scanning of arbitrary JSON. +Preview names, sizes and provenance before readiness, including imported material +that will become committed; publication authorization covers that inclusion. Do not +publish every capture in the store. Add the managed paths and exact bytes through +existing logical/final-candidate topology and regeneration owners before verification. +Reject collisions, missing captures and inconsistent bundles. Do not mutate accepted +policy text or leave untracked staging artifacts to satisfy the current resolver. + +This deliberately preserves portable `repository-content@1` receipt semantics: +a cold reader finds the exact referenced bundle in the destination repository and +validates its digest using the existing receipt/trust path. Bundle provenance is +independently inspectable. No old receipt is reinterpreted as snapshot-bound, and no +blanket EvidenceReference or coverage-receipt migration is assumed. If a real +consumer requires raw content instead of the bundle carrier, or generic provider +admission cannot preserve its contract, stop at A2's small vertical proof and own a +versioned alternative; do not disguise raw bytes as bundle bytes. + +**Origin is not subject or authority.** A baseline page may support before-state +reasoning; its capture does not prove after-state correctness. Existing obligation, +fingerprint, coverage and capability contracts decide whether the evidence is +admissible for a decision. External run claims remain claims unless a trusted +provider actually verifies them. No automatic baseline/candidate rebinding or +acceptance is inferred from matching bytes. + +### D4 — Diagnostics travel from the failing owner through the authorized boundary + +`ResolvedEvidence` currently raises a digest mismatch without details, and generic +Engine rejection discards available AnalysisFailure path/field/observed context. +Correct both ownership boundaries: produce exact structured mismatch data at +resolution/preflight, then project permitted bounded context through the existing +error machinery. Use reference ID, provider/version, validation phase, source kind +and material identity, expected/observed digest, and proposed next action. Absence +of readable bytes has no fabricated observed digest. A batch identifies the failing +member without reflecting arbitrary malicious keys or dumping evidence contents. + +Authoring permission is required for private locators, subjects or provenance. +Application outputs keep their existing disclosure policy; do not globally expose +AnalysisFailure.observed or Git stderr. Distinguish invalid evidence, unavailable +source, unsupported provider, revoked authorization and stale subject. Preserve +machine-readable codes and add an explicit diagnostic extension only where needed. +Historical diagnostic payloads are not retroactively altered. `readiness-preflight`, +`decision-authorization`, `candidate-evidence`, `final-verification` and `recovery` +are phase values owned by the operation that supplies the context, not guesswork in +a generic hash validator. + +### D5 — Reconciliation is a separate, explicitly authorized local operation + +Add one authoring operation, provisionally `reconcile_application`, with observation +as its default and an explicit apply action. Input identifies the stored application +and one selected worktree; execution also supplies its exact preflight observation +binding. Do not use `recover_application` to conceal checkout writes: existing +recovery concerns canonical publication and durable outcomes only. + +The first supported mutation is intentionally narrow: synchronize publication-owned +paths while carrying forward unrelated staged/unstaged/untracked work. Use a reviewed +Git two-tree operation through Repository Git, with expected predecessor and exact +published candidate; the feasibility trial used `read-tree -m -u old new`. This is +not a recipe to issue blindly. Derive the permitted path set, verify actual HEAD/ref, +index entries, modes and file states, and classify conflicts before effect. A +conflicting publication path or untracked obstacle refuses rather than merges or +overwrites. Do not silently stash, reset, clean, switch branches, write a commit, +advance the target again, or synchronize every linked checkout. + +Protect private/common Git directories, linked-worktree identity, index locks and +no-follow filesystem boundaries at Repository Git. Preserve unrelated staged and +unstaged distinctions, not merely their combined bytes. Existing lockfiles belong +to their owner and are not deleted. Admit only explicitly supported regular-file +layouts initially; sparse/split indexes, unmerged entries, gitlinks, case collisions, +custom filters and other unsupported modes need explicit rejection or separately +proved support. Do not claim a platform matrix from Linux-only tests. + +The Git index lock does not lock arbitrary editors or the branch ref. Establish +exclusive/cooperative ownership of the selected publication paths during mutation, +revalidate the ref/worktree/index observation at admission, and observe afterward. +Declare that local concurrent actors bypassing that ownership are outside the +supported write guarantee; hashing twice is not a replacement for ownership. A +changed or unavailable observation yields stale/unavailable, not permission to +retry with new assumptions. Do not add elapsed-time expiry to a valid user task. + +There is no atomic transaction spanning SQLite, ref, index and filesystem. Before +mutation retain sufficient exact operation intent/preimages under the existing +owned lifecycle to explain a partial attempt. On failure inspect actual state and +return `reconciliation-required` or `unknown` as appropriate while preserving the +already-published receipt. Do not rollback over newer user bytes. A later explicit +observation/completion must reuse the admitted intent and remain idempotent. Any +journal/artifact added for interrupted reconciliation has a named owner, version, +byte bounds and retention; use no second generic task engine. If safe write ownership +or recoverable partial effects cannot be established, ship the truthful observation +and keep the write capability unsupported until that proof exists. + +### D6 — Explain exposure and reuse decisions at their existing owners + +Have application qualification return an internal structured blocker carrying the +actual blocking module, its exposure state and dependency edge/chain. The authoring +`preview_application` projection can show it and a supported inspect/read request. +The application-purpose adapter keeps its non-disclosure projection. Preserve valid +exposure rules; an approved detail does not automatically approve its Router or +other prerequisites. Bound dependency explanations and avoid partial private content. + +Pass an explicitly available predecessor Analysis from focused `revise` to the +existing retained-decision evaluation path. The original records remain immutable. +Reuse fact observations, coverage attestations and dispositions only when the current +execution contract, subject, dependency fingerprints, evidence and authorization +still validate. Matching a fingerprint is necessary in the reproduced case, not a +universal authorization shortcut. Never swallow an unrelated corruption/authority +error as "not reusable". No hidden store-wide latest-Analysis search is introduced. +A bare revision without a selected Analysis stays explicit; do not invent prior work. + +Expose bounded `reused`, `needs-decision`, `changed-dependencies` and `new-obligation` +information derived from the evaluator's actual comparisons. Include exact dependency +class/identity and old/new digests only to the authorized author. The source already +owns structured dependency fingerprints; there is no need for a second graph or a +heuristic "metadata is harmless" test. + +Final `ProposalReadiness` decisions bind Analysis, revision and expected target. +They are not automatically copied onto a successor. Reusing lower-level decisions +can remove repeated submissions while a new final review still authorizes its new +subject. A broader cross-revision approval policy would be a different admitted +contract, not part of this plan. + +### D7 — Make the successful path concise without another identity system + +Use existing compact workflow summaries and explicit detail reads. Include new +publication/evidence/reuse information once in the result, with exact handles needed +for durable continuation. Full detail remains available. Human-friendly labels are +display-only; no short-ID resolver, server session or loss of cold continuation. + +Provide contract-checked task examples for original evidence versus bound evidence, +changed candidate evidence, required read_many snapshot, resolve_many, review, +apply/observe and explicit reconciliation. Reuse discovered shared definitions; +do not restore large eager description-embedded schemas or require discovery before +every call. Measure the actual authoring trace and repair counts. Do not claim fewer +model tokens, latency or calls from JSON-size changes alone. + +### D8 — Version actual boundaries, not all history + +The inspected public interface is 45. New outputs/actions require the next unused +interface edition (46 if still unused at implementation). If milestones deploy +separately with later contract changes, version each actual release; do not force +unrelated integrated work back to a planned number. Update a1-interface, canonical +schema, generated models/catalogs/examples and direct clients atomically. + +Keep existing proposal/revision, Analysis, readiness, application and coverage-receipt +encodings unless a specific new persisted representation changes their selected +meaning. Evidence captures and reconciliation intent have their own new discriminated +record kinds/versions and exact identity inputs. Their bytes may cause new candidate +commits, as expected; they do not retroactively alter old revision IDs. Retain real +old record readers where required by installed data, with exact version dispatch; +this is not revival of retired input-schema compatibility. + +Cold old-producer/new-consumer checks must cover historical snapshots, proposals, +Analysis, readiness, admitted recovery and published v1 receipts. Do not fabricate +missing origin or checkout-before state for legacy references/applications. Missing +source data is unavailable, not a migration-by-guessing. No store deletion, mass +rewriting of accepted receipts, or automatic conversion of old evidence into bundles. + +## Simplicity And Ownership Review + +**Applicability:** `applicable` + +- Independent concepts and dimensions: Git publication, checkout synchronization, + evidence acquisition, evidence admissibility, authorization, exposure and rendering + change for different reasons. Keep them at existing Git, Engine, Analysis and + projection owners. The new evidence-binding module owns only capture/bundle lifecycle. +- State, identity, value, time, policy, and mechanism: immutable evidence bytes, + revision and application facts remain exact values; live permissions, refs and + working files are observations. A bundle is source material, not decision truth; + a prior applied outcome is history, not a guarantee of present HEAD. +- Caller and composition-root knowledge: callers choose exact sources and actions, + then reuse references/contexts. They should not reconstruct commits from opaque IDs, + manually duplicate candidate bytes, infer why evidence changed phase, or script + index repair. Composition supplies the correct resolver and worktree authority. +- Representative change paths and forced owners: another exposure blocker changes + the qualification owner and authorized projection, not Git. An evidence-origin + extension changes binding/admission and export tests, not rule evaluation. Another + Git layout is admitted at Repository Git rather than through a facade workaround. +- Stable Interfaces versus hidden knowledge: canonical EvidenceReference and existing + portable receipt semantics are reused with explicit bundles; collection never + searches arbitrary JSON for evidence-shaped objects. Generic trust validators do + not know Engine private handles or read filesystem paths themselves. +- Independent evolution, testing, failure, and replacement: receipt reporting can + succeed while checkout observation is unavailable. Evidence capture/preflight and + reconciliation have separate negative/fault tests. Production publication remains + isolated from mutation of the selected checkout. +- Necessary complexity and containment: source provenance, late authority checks + and partial Git effects are genuine obligations. Keep the first reconciliation + conservative and bounded. Missing capability is explicit; no silent fallback to + reset or live-path evidence and no universal artifact/approval registry. +- Deletion and cumulative machinery result: remove duplicated destination-evidence + interpretation from phase-specific loops into one preparation owner; eliminate + focused re-submission by reusing the existing evaluator; propagate blocker data + rather than make authors rediscover it. At most two justified new focused actions + (bind evidence and reconcile application) replace manual multi-step work. Any new + abstraction must demonstrate reduced caller knowledge, not just smaller files. + +## Milestones + +### A1 — Explicit publication observations and early evidence failures + +**Status:** `Verifying` — the repaired implementation and local A1 gate are complete; exact-head hosted checks, the required Passeur security/lifecycle review, and main integration remain pending. + +**Goal:** make existing success/failure truthful before extending evidence capability. + +**Write set:** the existing engine.py, agent_workflow.py, tools.py error projection, +Analysis trust/error and coverage_publication preparation boundary; Repository Git +read-only publication/worktree observation; canonical contracts/generated files and +direct tests/examples/guidance; this plan. Correct the affected supporting-workflow +fixture and its cache-enabled caller without changing accepted Security exposure. + +**Work:** reproduce the recorded facade cases on the integrated candidate; add durable +receipt/fresh checkout observation; share side-effect-free evidence preflight before +readiness; expose bounded authoring phase/reference context; retain all final checks. +Create one planned coherent interface update, with exact old-consumer dispositions. + +**Gate:** The local A1 gate passed on the repaired candidate `fab920f4`. Publication and recovery preserve +checkout/index state; durable receipts remain distinct from fresh checkout +observations, including unknown outcomes and a replacement MCP process. Evidence +preflight rejects incompatible destination bytes and paths that publication will +overwrite before readiness; final candidate validation remains in place. No global +source-binding migration or new reconciliation write is hidden in A1. Exact-head +hosted checks and the required Passeur security/lifecycle review remain outstanding. +Do not begin A2's dependent implementation until A1 is accepted and merged to +`main`. See the implementation result in the [execution ledger](execution-ledger.md). +A2 extends the evidence matrix to bound references. + +### A2 — Explicit evidence bindings and portable artifacts + +**Status:** `Planned`; follows A1. + +**Goal:** safely use selected baseline/candidate/imported evidence across all phases. + +**Write set:** one new Engine evidence-binding module and its composition adapter; +existing Snapshot aggregate use, trust resolver boundary, logical/final candidate +assembly and managed evidence-path integration; canonical action/result contracts, +inspect/evidence normalization consumers, tests and guidance. Analysis coverage +receipt code changes only if the vertical proof establishes a necessary contract +extension; preserve v1 semantics and declare it before implementation expansion. + +**Work:** first prove one changed-page baseline acquisition through decision, +readiness, candidate inclusion and a cold receipt read. Then extend the same owner +to exact candidate and explicit local capture. Verify source digest, origin identity, +reachability, quotas, graph retention, no collision or self-reference, and disclosure +of exported evidence. Do not add source-independent authority or provider guessing. + +**Gate:** A-C3/A-C4 plus A-C2 for old and bound references; no original store/root +needed for exported receipt validation; mutated original local source cannot mutate +a bound artifact, while its governing live authorization/revocation still changes. +A successful static reference parse alone does not admit the provider/material. + +### A3 — Explicit, guarded checkout reconciliation + +**Status:** `Planned`; follows A1, integrated after A2 in this sequence. + +**Goal:** replace unsafe manual repair with one narrowly owned opt-in operation. + +**Write set:** Repository Git reconciliation primitives and direct tests; Engine +application coordination and optional versioned intent storage; generated operation, +result and permission declarations; tests and authoring instructions. No general +worktree management platform or publication-policy change. + +**Work:** turn the positive/conflict Git feasibility into a verified observation and +one explicit mutation, with supported-layout declaration and current-state guards. +Test uncertain outcomes and process interruption before advertising safe completion. +Keep no-effect repeated calls idempotent and late changes visible. Default is observe. + +**Gate:** A-C5, verified preservation of unrelated index/worktree distinctions, +conflict refusal and recoverable partial effects. Arbitrary same-file merging is +unsupported. If the initial supported-layout proof fails, retain truthful observation +and block only the write capability rather than weakening its safety promise. + +### A4 — Explain candidate blockers and reuse valid Analysis decisions + +**Status:** `Planned`; follows A1–A3. + +**Goal:** reduce rediscovery and renewed submissions without reusing approvals blindly. + +**Write set:** context_projection/qualification internal blocker representation; +engine retained-decision reuse; focused workflow composition/presentation; generated +bounded diagnostic/summary types and examples; direct purpose/reuse tests and guide. + +**Work:** preserve application redaction while exposing authoring cause chains; pass +selected predecessor Analysis into the existing evaluator; return precise validated +reuse/invalidation summaries; add concise real-task examples, including read_many's +required snapshot. Keep final review bound to the successor. + +**Gate:** A-C6/A-C7, literal old/new dependency cases, no unauthorized disclosure, +fresh evidence/capability checks, same result as explicit fresh decisions, no added +mandatory discovery or status call, and bounded compact/full equivalence. + +### A5 — Supported integration, author workflow and independent acceptance + +**Status:** `Planned`; follows the coherent source candidate. + +**Goal:** establish externally meaningful improvement and close only this plan. + +**Write set:** qualification instruments, current guides, plan/evidence and generated +verification inputs. Repairs stay at the preceding owners unless a re-plan trigger +changes their meaning. No production policy edits to fabricate a qualification task. + +**Work:** run the current unchanged locked Python 3.12 CI selections including repaired +baseline fixture tests, cold old/new records, a separate recipient's evidence read, +and an authorized fresh agent task in a disposable repository. Record runtime/catalog, +exact source/tree, source locator, all publication observations, required decisions, +repair/discovery counts, and unrelated Git state before/after. Compare like-for-like +steps; explain intentional diagnostic/contract changes. Review the coherent source +independently and verify only actual repairs afterward. + +**Gate:** every A-C claim supported at its named fidelity, findings dispositioned by +the acceptance owner, exact candidate integration identified. Reuse valid earlier +evidence within scope; no full CI rerun merely to rewrite a passed result's prose. +No automatic acceptance by a tool or by this planning review. + +## Required Verification Matrix + +- **Publication:** current target checkout, detached/other branch, later target advance, + unrelated staged+unstaged on one file, untracked files, overlapping changes, + missing old objects, failed result persistence, target moved during publication, + post-publication observation failure, restart and repeated observe/recover. +- **Evidence:** changed/deleted evidence path, unchanged context evidence, baseline vs + exact candidate bytes, explicit imported file, false provider/source, bad digest, + unsupported type, missing snapshot/aggregate/object, size limits, denied capability, + revoked authorization, capture failure, portably exported artifact and tampering. + The actual changed-page fixture must fail before readiness with legacy reference + and succeed with a correctly authorized bound artifact, not a replacement digest. +- **Reconciliation:** clean old index, already current, unrelated index/worktree deltas, + overlapping same file, untracked obstacles, additions/removals/mode changes, + linked worktrees, stale observations, locks, unsupported index/layout, hostile + filters/configuration, partial write/cleanup failure and replacement process. + Test user-file preservation by exact bytes/modes/staging, not merely Git status. +- **Reuse/exposure:** unchanged dependency with unrelated edit; changed module, + applicability, provider, execution authority or evidence; removed obligation and + new obligation; explicit unknown facts; denied private Router; multiple blockers; + bounded chains and safe application rejection; selected Analysis versus bare revision. +- **Regression:** existing publication/recovery, consumer registration, coverage and + receipt, request evidence, proof reuse, snapshots, generated contracts and relevant + Git tests; current full required CI and structural checkpoint. Mutations exercise + the old failure where meaningful; normal acceptance tests use real owners. + +## Blockers + +There is no blocker to A1 source work after explicit admission. The precise original +agent run is unavailable, so do not claim a historical transcript replay. The pinned +baseline has a known test-fixture CI failure; its correction belongs to A1's narrow +qualification setup. The evidence-bundle carrier and recoverable reconciliation are +new capability proofs required in A2/A3, not assumed completed implementations. +The actual host/model and independent reviewer are not executed in this planning +task; A5 owns their authorized procedures. Source work must not imply those passed. + +## Re-Plan Triggers + +Re-plan if evidence requires an independent provider or stronger origin authentication, +if bundle carrier semantics cannot satisfy actual consumers, if self-reference or +portable-history support requires reinterpretation of old receipts, if safe Git +write ownership cannot be provided for the promised supported layout, if equivalent +prior Analysis decisions cannot pass existing fresh authorization, or if current +source changes alter the verified baseline assumptions. Declare actual new public, +persisted or security boundary changes before implementation; do not install a +fallback parser, speculative cache or broad framework to avoid the decision. +A discovered direct consumer of the selected contract extends that write set with +an issue disposition; it does not automatically reopen unrelated accepted projects. + +## Final Acceptance + +This is a reviewed **plan**, not a source implementation or new acceptance verdict. +Baseline observations, the 2000-dated deterministic publication, passing structural +checks and prior external reports do not qualify the future candidate. Keep original +failed probe drafts, CI failures, repaired fixtures and final candidate results at +their actual identities. Source/CI review is separate from authoring publication; +no production mutation, remote push or acceptance-status change occurred here. + +After A1–A5 satisfy their claims, close this plan and retain non-blocking observations +as explicitly deferred new work. No next refactor is automatically admitted. + +- Acceptance status: `pending` +- Final status: `Planned` diff --git a/docs/plans/authoring-publication-evidence/reports/code-review.md b/docs/plans/authoring-publication-evidence/reports/code-review.md new file mode 100644 index 00000000..88648c55 --- /dev/null +++ b/docs/plans/authoring-publication-evidence/reports/code-review.md @@ -0,0 +1,226 @@ +# Authoring experience — source review and planning evidence + +## Disposition + +The current code supports four reported friction mechanisms. The most important +changes concern the publication result and evidence preparation/resolution, not +removing integrity checks. A changed-evidence rejection is correct; the incomplete +readiness explanation and late discovery are the problems. Git ref publication is +also correct within its current contract; it intentionally leaves the index and +worktree untouched. The interface does not make that distinction sufficiently useful +for the agent's next operation. + +This is a new source review and a planning delivery. It is not an independent external +acceptance review of earlier code authored in this conversation, a production repair, +or a status change for existing plans. The attached historical external report is +historical evidence with its own source/CI limits; it is not substituted for current +source or used to reopen accepted slices. + +## Source and method + +- Candidate: `149ba317e9397519bc181a048ecf76aef129a69c`. +- Tree: `fdd40edc1eea85398e97b740a595a42631614d0b`; interface 45. +- Runtime source has no `tools/` change from parent `39d55dc3`; the latest commit + publishes Security/Concurrency guidance, metadata and coverage. The review does + not infer that this is the exact original feedback session: its handles and + transcript were not supplied. +- Exact Actions artifact `11036434347`, from run `36574954850`, verified against + SHA-256 `34d36acefcb3b9c4be1bf096797bbd3c111f893f2c8bb2ca8c0e2d00be802f0f`. +- Scope: publication/recovery/receipt path, local evidence authorization and portable + coverage, focused workflow reuse, application preview, related contracts and tests, + current governing standards and baseline CI. This is not a whole-repository audit. +- Read-only source checkout; probes create and operate only on task-owned disposable + repositories/stores. No user checkout, retained production state, remote branch, + acceptance record or provider configuration changed. + +## F1 — Applied target, unresolved checkout (confirmed) + +`publish_candidate` imports verified objects and performs an expected-old +`update-ref` on `refs/heads/main`. It deliberately does not replace the user's index +or worktree. The ordinary `apply-proposal-result` returns an application handle and +`status: applied`; the focused workflow adds its usual context but no commit/ref/ +index/worktree observation. A later applied `workflow_status` likewise does not +expose the selected publication's material receipt and current checkout condition. + +**Probe:** a real facade proposed and reviewed a new reference, then published it +with both a staged and unstaged unrelated README change and an untracked file. +The real candidate verifier ran. Apply returned `applied`; main advanced; the exact +index bytes and user README bytes were preserved. Relative to the new main, Git +reported staged reversals of generated metadata and a staged deletion of the new +reference. This is the agent-visible state from the report, not an overwritten-user- +change reproduction. + +Required improvement: preserve isolation, expose both outcomes, and provide only an +explicit guarded reconciliation action. Do not make apply reset the checkout. Code: +[Git publication](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/repository_git/repository_git/repository.py#L631-L692), [apply](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/engine.py#L1329-L1464), [workflow projection](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/agent_workflow.py#L105-L178). + +**Feasibility:** on this private fixture `git read-tree -m -u old new` synchronized +the published paths and preserved the unrelated README's staged/unstaged distinction +and untracked file. A separate overlapping-file fixture refused with exit 128, +preserving its index, conflicting bytes and target. This validates one primitive, +not a complete Engine API, concurrent-editor exclusion or interruption recovery. +Those are explicit implementation gates in A3. + +## F2 — One evidence reference is resolved against different material (confirmed) + +The local facade authorizer uses `DirectoryContentSource(root)` for all +`repository-content@1` references. Decisions therefore read the working tree. Final +coverage publication separately reads those same IDs from the proposed destination +source. Its portable receipt reader later reads them from the published source. +These are three concrete material contexts; the four-field reference identifies +path/digest/provider but not which originating source the author intended. + +**Probe:** an audit of `workflow.commit.commit-message` was combined with a change +to `prompts/planning.md`. The unchanged working-tree prompt served as explicit +fixture evidence. The actual resolve sequence reached complete, and review returned +ready. Both explicit `verify_proposal` with that readiness and apply returned +`ANALYSIS.EVIDENCE_DIGEST_MISMATCH`. Main and the working-tree evidence remained +unchanged. No captured evidence was fabricated or production approval submitted. + +Important qualification: an existing explicit candidate verification operation +already catches the mismatch before apply. The interface's ordinary review-to-ready +path does not perform that evidence-destination preflight. The fix is not to remove +candidate checking, require blind apply retries, or claim readiness guarantees final +authority can never change. Share the deterministic evidence preparation and make +its failures visible earlier. + +Code: [local resolution](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/tools.py#L54-L106), [portable publication](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_analysis/standards_analysis/coverage_publication.py#L124-L178), +[portable readback](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_analysis/standards_analysis/coverage_publication.py#L202-L223), [review boundary](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/engine.py#L1252-L1326). + +The plan proposes explicit captured evidence bundles because current portable +coverage deliberately requires repository-content version 1. A broad source-label +field or simply permitting external references would not update the receipt reader's +meaning. A self-contained managed artifact can preserve the existing reference +carrier and portable resolution while retaining original baseline/candidate/imported +provenance. That is a design proposal with a required vertical proof, not an +implemented or universally validated new evidence system. + +## F3 — Missing evidence diagnostic context (confirmed) + +The mismatch above returned an empty `details` object: no reference, phase, path, +expected/actual digest or source identity. `ResolvedEvidence` raises a message-only +AnalysisFailure. The generic Engine adapter also projects most domain failures as +only code/outcome/message, discarding optional contextual fields that some other +owners supply. Fix the producer and the authorized projection; do not make a generic +adapter emit arbitrary raw values or private material to application clients. + +Code: [digest validation](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_analysis/standards_analysis/trust.py#L70-L88), [domain rejection](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/engine.py#L3460-L3484). + +## F4 — Existing valid reuse is not connected to focused revise (confirmed, bounded) + +Focused `revise` creates/analyzes the successor without passing its selected prior +Analysis. `_analyze_proposal` starts a new state with repository coverage, not prior +session dispositions. Meanwhile native `prepare(prior_analysis=...)` already uses +`_reuse_prior`, which checks execution contract and reevaluates retained decisions. + +**Probe:** one normative fixture obligation was resolved to complete. Adding an +unrelated reference through focused revise returned needs-action again. One old/new +obligation fingerprint was exactly identical. Applying the existing `_reuse_prior` +to the real successor in memory retained the one disposition and evaluation became +complete. No derived Analysis was published by this feasibility check; current +source/evidence/authorization owners still ran. + +This establishes one safely reusable Analysis decision, not permission to carry +all decisions or final readiness across revisions. Final review subjects expressly +include Analysis/revision/target. The plan retains that stronger binding and exposes +why other decisions became stale. + +Code: [fresh proposal Analysis](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/engine.py#L1183-L1248), [focused revise](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/agent_workflow.py#L219-L265), +[existing validated reuse](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/engine.py#L2456-L2496), [readiness ownership](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/authoring.py#L780-L848). + +## F5 — Candidate exposure failure loses the blocking identity (confirmed) + +The qualification traversal knows exactly which module fails current exposure, +but raises an empty `_UnqualifiedContent`. Authoring preview then emits the generic +application rejection plus a suggestion to inspect exposure elsewhere. + +**Probe:** changing only a Router rule's displayed condition made Router exposure +`needs-review`. The real candidate route preview returned `APPLICATION.CONTENT_UNAVAILABLE` +with no blocker details. A separate authorized Router read returned its exposure +state. This is appropriate denial with an avoidable explanation round trip. + +Return structured internal blockers and expose them only through the authorized +preview. Do not make ordinary application errors disclose private module names or +authorization state. Code: [qualification](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/context_projection.py#L110-L126), [preview](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/standards_engine/context_projection.py#L250-L268). + +## F6 — Baseline CI fixture now assumes obsolete production exposure + +Current source workflow `36574954850`, job `109428068403`, failed its Engine phase: +611 executions, two errors. Both enter +`test_supporting_workflow.test_coordinated_publication_and_provenance_only_revision` +(directly and through the process-reuse wrapper). The test indexes `empty['code']` +after reading topic.security and expecting content-unavailable. The latest +publication makes that real topic visible, so the positive result has no error code. +A separate run of the fixture setup and its initial application read reproduced +`application-read-result` without a `code` field. This is a fixture setup assumption +exposed by a standards change, not proof of an application-authorization bypass. + +Repair the starting fixture to control its own exposed/unexposed module and retain +positive and negative assertions. Do not revoke real Security exposure or merely +accept either result. This repair belongs in candidate verification; the plan must +not assume baseline CI is green. The pre-Engine supporting selections all passed. +The workflow stops after Engine failure, so it did not reach its final structural +command. A separate local structural invocation passed. Code: [fixture](https://github.com/MrScripty/Coding-Standards/blob/149ba317e9397519bc181a048ecf76aef129a69c/tools/standards_engine/tests/test_supporting_workflow.py#L78-L86). + +## Reported concerns not promoted to unproved defects + +The exact client's abbreviated declarations, pagination effort, and response token +cost were not measured here; no live model session was run. Existing compact +summaries and selective input/output discovery already exist. The plan improves +current task examples and measures the coherent authoring workflow, but does not +restore eager embedded schemas or create short-ID resolution as an assumed cure. +The reported invalid read_many call remains a caller error; its required snapshot +belongs in the example, not removed from the authority contract. + +External evidence is supported architecturally through authorization adapters, but +the inspected local adapter deliberately accepts only repository-content@1. Do not +mistake that deployed boundary for a missing generic network provider or make +outside URLs trusted by labelling them external. + +## Verification and limitations + +Actual local selected suites: 22 Engine authoring/recovery/digest tests passed; +125 Analysis tests passed; 40 Repository Git tests passed and one permission- +dependent case skipped. Total: **187 passed, one skipped, zero failures** across +188 test executions. Full Engine/remaining package suites were not rerun. +The complete structural checkpoint separately passed 73 suites / 121 checks. +The pinned hosted run is failed as recorded above; local selection does not replace it. + +The four actual-facade scenarios and two feasibility experiments are separate from +those unit-test totals. Normal publication used the actual verifier. Existing +recovery tests use their declared verifier substitute for injected faults; this is +not represented as independent full-verifier evidence for each recovery scenario. +Two initial probe drafts failed before the relevant observation (missing fixture +condition/unhashable fingerprint), and one used a colliding fixture directory name. +The corrected probes passed; originals and their errors remain in the evidence. +A supplementary CI-fixture probe initially omitted class-level setup and was +corrected before making its observation; that setup mistake is recorded separately. +None was a production-code failure or silently counted as a successful test. + +Environment: Python 3.13.5, Git 2.47.3, jsonschema 4.26.0, rpds-py 2026.5.1. No +local supported locked Python 3.12 run, no platform other than Linux, no hostile +concurrent checkout trial and no external/model reviewer were executed. The original +feedback's exact private records remain unavailable. The new plan, links and its +required fields are checked separately; validation of a plan is not acceptance of +its unimplemented claims. + +## Selected implementation sequence + +A1: truthful publication/checkout observations and early evidence diagnostics. +A2: explicit immutable evidence acquisition/export with preserved portable semantics. +A3: opt-in guarded checkout reconciliation with owned partial outcomes. +A4: scoped exposure explanation and existing validated Analysis reuse, with examples. +A5: exact supported integration, actual disposable agent task and independent review. + +There is no source patch in this delivery. Use the canonical plan for future `start` +admission; current findings do not reopen prior accepted scopes. + +## Corroborating Git contract + +The official read-tree documentation specifies its two-tree carry-forward behavior, +including preservation of unrelated local changes and refusal of overlapping changes. +The observed fixture supports that bounded use; it does not establish atomicity of +Git refs, the index and arbitrary filesystem writes together. + +- https://git-scm.com/docs/git-read-tree +- https://git-scm.com/docs/git-update-ref/2.45.0 diff --git a/docs/plans/authoring-publication-evidence/reports/mcp-usability-feedback.md b/docs/plans/authoring-publication-evidence/reports/mcp-usability-feedback.md new file mode 100644 index 00000000..de5e20c8 --- /dev/null +++ b/docs/plans/authoring-publication-evidence/reports/mcp-usability-feedback.md @@ -0,0 +1,49 @@ +# Standards Engine MCP usability feedback + +**Observed:** 2026-09-29, while admitting A1 from the isolated implementation +worktree. The live MCP reported interface 45 and implementation 0.2.0, with the +installation current and suitable for reuse. It was not restarted or modified. + +## Calls and results + +| Call | Result | Usefulness | +| --- | --- | --- | +| `runtime_info` | Returned the live interface, implementation, and installation state. | Useful to confirm the existing process could be reused before reading standards. | +| `routing_facts` | Returned snapshot `snapshot:v1:322889ba-df55-43d9-a2a5-68c1993dd498`. | Useful stable boundary for the rest of the authoring reads. | +| `route` with selected implementation, planning, verification, and commit concerns, plus architecture, contracts, security, diagnostics, and workflow tags | Returned an oversized result that was truncated by the caller. | The selection itself was relevant, but the chosen broad route did not fit the available response window. | +| `read_many` for the selected core, implementation, planning, commit, verification, standards-authoring, architecture, code-design, contracts, and security materials | Returned the selected source material against the same snapshot. | More useful for focused reading after the route response was too large. | + +The practical sequence was to check runtime state, capture one snapshot, request +a bounded selection, then read only the sources needed for this change. `route` +remains useful for discovery, but broad combined topic/tag selection should be +split or followed by `read_many` rather than consumed as one large result. This is +feedback from one authoring session, not a general latency or reliability claim. + +The root implementation agent made the MCP calls. The fixture and architecture +review workers did not use MCP; their work used the isolated repository source, +tests, and the admitted plan. Local Engine verification was performed through the +owner's `verify_repository(refresh_verification_inputs=True)` operation and did +not restart or replace the live MCP process. + +## 2026-09-29 — final A1 routing check + +The integration owner reused the same snapshot for the final A1 obligations check. +`routing_facts(snapshot)` made the registered fact vocabulary and allowed values +available without capturing another view. The first `route` call returned +`needs-facts` because the owner had omitted the framework fact; supplying the +observed empty framework set produced a complete route with no unresolved +questions or policy items. The explicit missing-fact result was useful and the +correction was small. + +The complete route selected 30 standards. A broad `read_many` page for eight +selected standards returned more source text than the caller window could retain. +Reading a smaller, named subset is the safer way to inspect obligations; the +route selection itself remained useful. A concise per-standard summary or a +caller-selectable content budget would reduce truncation while preserving exact +source reads on demand. + +Only the integration owner reports Standards Engine MCP use. The GPT-6.1 Sol +fixture writer, Astra architecture and standards reviewers, Luna spec reviewer, +observer reviewers, and archive/plan discovery workers reported no MCP calls; +their source and acceptance findings are recorded in the execution ledger. Their +MCP usability experience is therefore not inferred from the owner's calls. diff --git a/docs/plans/authoring-publication-evidence/reports/pr-draft.md b/docs/plans/authoring-publication-evidence/reports/pr-draft.md new file mode 100644 index 00000000..817bdc46 --- /dev/null +++ b/docs/plans/authoring-publication-evidence/reports/pr-draft.md @@ -0,0 +1,114 @@ +# Pull request draft + +**Title:** feat(standards): clarify publication and preflight evidence + +## Owning plan and milestone + +- Plan: `docs/plans/authoring-publication-evidence/plan.md` +- Milestone: A1 — Explicit publication observations and early evidence failures +- Target: `main`; accepted base: `149ba317e9397519bc181a048ecf76aef129a69c` +- Repaired source candidate tested: `ecbf25cdcd8218b44e68b6adb359c7efaeea765d` +- Draft PR: [#2](https://github.com/MrScripty/Coding-Standards/pull/2) + +## Intended outcome + +- Report durable publication receipts separately from fresh, read-only target, + worktree, and index observations across apply, recovery, and later status. +- Preflight destination evidence before readiness, preserve final evidence and + authorization checks, and expose bounded authoring diagnostics with application + redaction. +- Coordinate interface 46, result projection 8, generated consumers, and exact + interface 45 client-upgrade dispositions while retaining request contract 6 and + application/readiness persistence schemas. +- Make publication observation own descriptor exhaustion, path/root races, and + cancellation cleanup, including a local-only read of the canonical target ref. +- Keep reconciliation writes and evidence bundle acquisition for later milestones. + +## Prerequisites and exclusions + +The branch starts from accepted `main` at +`149ba317e9397519bc181a048ecf76aef129a69c`. The local A1 gate passed on the +repaired source candidate. The plan remains `Verifying` until a successful +exact-head hosted run, the required Passeur review, and accepted main integration +are complete. +Pumas-Library acquisition/runtime plans are separate; Q1/AQ-HTTP is not ready and +is not an A1 dependency. + +A1 excludes A2 evidence binding, durable evidence-bundle acquisition, reconciliation +writes, Pumas consumers, and migration of existing application/readiness persistence +formats. + +## Ownership, persistence, security, and lifecycle + +Repository Git owns fresh checkout/index observation and descriptor lifecycle; +Analysis owns evidence validation; the Engine owns publication projection. Durable +receipts and existing publication authorization remain authoritative. The change +does not alter request contract 6 or application/readiness persistence schemas and +requires no retained-state migration. Descriptor exhaustion, filesystem races, and +cancellation release observation resources. Application-facing diagnostics remain +bounded and redact private exception text. Readiness preflight rejects references +that publication will overwrite; final candidate validation remains intact. + +## Validation + +On integrated candidate `ecbf25cdcd8218b44e68b6adb359c7efaeea765d`, Python 3.12 +with the hash-locked requirements, offline: + +- The seven existing A1 modules (`test_repository`, `test_analysis`, + `test_coverage_publication`, `test_agent_workflow`, `test_publication_recovery`, + `test_registration_contract`, and `test_supporting_workflow`) plus five + current-interface consumer modules (`test_capture_handoff_transport`, + `test_consumer_publication`, `test_routing_fact_transport`, + `test_runtime_identity`, and `test_schema_presentation`) passed **108 tests in + 427.181 seconds**. The five consumer modules independently passed 24 tests in + 165.995 seconds. The diagnostics regression retains valid bounded spaced, + Unicode, and dot-prefixed repository references while preserving application + redaction. +- `verify_repository(refresh_verification_inputs=true)` and the subsequent + `refresh_verification_inputs=false` run each passed **73 suites and 121 checks**; + refresh produced no manifest change. `tools/standards_verifier/verify.py + --complete` passed all 73 suites with zero failures or blocked checks. +- `git diff --check` passed. + +The suite exercises test-owned local Git repositories and controlled failure, +race, cancellation, readiness, and destination-overwrite cases. Mocked boundary +assertions are unit evidence, not evidence of real partial-clone or hosted-service +behavior. No live remote repository or hosted MCP publication was qualified. + +## Independent review and outstanding acceptance + +GPT-6.1 Sol high's read-only review of `f676cfaf` found two P2 gaps: unbounded +phase-specific evidence diagnostics and acceptance of evidence at paths publication +would overwrite. GPT-6.1 Sol medium repaired both in `01bb2d03`; Sol high's +read-only follow-up confirmed both findings closed and found no new actionable +issue. The regression tests bound diagnostics and reject overwritten evidence and +exclusions before readiness or candidate publication. + +Earlier Standards Engine routing selected 30 applicable standards with no +unresolved questions; the resulting obligations were checked against the source. +GPT-6 Luna High's bounded spec/reference review found no remaining gap in the +reviewed A1 contracts. The required Passeur security/lifecycle review remains +outstanding because the available service is bound to Pumas-Library; no review was +sent through that unrelated repository context. + +GPT-6.1 Sol high classified all nine failures on the earlier candidate's hosted +run as stale current-interface expectations, not intentional interface-45 client +fixtures. GPT-6.1 Sol medium changed exactly five installed-interface assertions +to 46 in the reviewed commit above; all other lifecycle, disclosure, and legacy +client checks remain intact. Sol High's read-only architecture review then found +that authoring diagnostics dropped otherwise valid spaced, Unicode, and +dot-prefixed evidence paths. Sol medium fixed the bounded authoring projection in +`e6da2e5f` with focused coverage for supported and unsafe paths and application +redaction; Sol High's follow-up confirmed closure with no further architecture +findings. The generated suite-input digests were refreshed and committed in +`ecbf25cd`. + +Hosted run `36648831399` failed on the stale assertions after 612 tests and did not +reach its structural-verifier step. Prior exact PR-head run `36651259589` is for +`95b13802` and also failed on those stale assertions. Run `36653728027` is for +`6921489c` and remained in progress at the time of this report; it predates the +path-diagnostic fix and refreshed digests. A fresh successful exact-head hosted +run for the current candidate is pending. PR #2 remains draft. No merge is +requested or performed. +Maintainer-authorized main integration remains required before A1 is accepted and +A2 implementation begins. diff --git a/docs/plans/authoring-publication-evidence/reports/source-consumers.md b/docs/plans/authoring-publication-evidence/reports/source-consumers.md new file mode 100644 index 00000000..ab19bd19 --- /dev/null +++ b/docs/plans/authoring-publication-evidence/reports/source-consumers.md @@ -0,0 +1,75 @@ +# Source consumers and version boundaries + +All inspected references below use source `149ba317e9397519bc181a048ecf76aef129a69c`. +Rows are the admitted owner families, not permission for unrelated cleanup. At each +slice, enumerate actual symbol callers and tests before editing; extend this list +only for a demonstrated direct consumer. Shared contracts/generator inputs have one +serial integrator. Code review is [here](code-review.md). + +| Owner | File | Current section | Planned disposition | +| --- | --- | --- | --- | +| Repository observation/publication | `tools/repository_git/repository_git/repository.py` | 631–692; existing index/command helpers | Observe exact target/worktree/index; new guarded local reconciliation primitive. Preserve isolated candidate and expected-target ref writes. | +| Git tests | `tools/repository_git/tests/test_repository.py` | publication/index, separate-layout cases | Keep existing preservation oracles; add two-tree/conflict/stale/partial-effect matrix without altering user Git config. | +| Engine application | `tools/standards_engine/standards_engine/engine.py` | 1252–1810 | Shared pure evidence preparation, rich publication view, explicit reconciliation coordination and final live checks. | +| Evidence resolution | `tools/standards_engine/standards_engine/tools.py` | 54–106; facade operation adapters | Separate resolver from permission policy; expose bounded new generated operations and references. No imports from Engine back into facade. | +| Trust values | `tools/standards_analysis/standards_analysis/trust.py` | EvidenceReference/ResolvedEvidence; authorization records | Keep exact digest/subject/capability validation; add safe context at owning resolution boundary, not global data echoes. | +| Error owner | `tools/standards_analysis/standards_analysis/errors.py` | AnalysisFailure | Extend only demonstrated diagnostic needs and preserve typed outcome/codes. | +| Portable coverage | `tools/standards_analysis/standards_analysis/coverage_publication.py` | 124–178,202–223,226+ | Keep current v1 destination semantics and cold read; share pure preflight and validate new exported bundles as existing repository artifacts. | +| Coverage parser | `tools/standards_analysis/standards_analysis/coverage.py` | 1068–1160 | Existing repository-content@1 rule constrains any extension; no broad provider relaxation. | +| Immutable authoring | `tools/standards_engine/standards_engine/authoring.py` | review_proposal/application/readiness records | Retain old identities. Introduce separate capture/reconciliation record kind only if necessary, not new meaning for old readiness. | +| Workflow composition | `tools/standards_engine/standards_engine/agent_workflow.py` | 105–178,219–326 | Publication facts visible on status; pass selected prior Analysis on revise; no final approval carryover. | +| Operation-local material | `tools/standards_engine/standards_engine/operation_materials.py` | ProposalMaterials | Reuse exact materials where legal without retaining current permissions or recovery authority. | +| Workflow display | `tools/standards_engine/standards_engine/workflow_presentation.py` | summarize/pending_work | Concise receipt/decision summary, precise safe continuations and bounded full detail. | +| Purpose qualification | `tools/standards_engine/standards_engine/context_projection.py` | 110–126,250–268 | Structured internal blockers; authorized candidate explanation versus application-safe rejection. | +| Logical/candidate assembly | `tools/standards_engine/standards_engine/logical_authoring.py` | projection topology and generated artifacts | Only explicitly selected captured evidence joins candidate files; exact topology/content and final manifest remain owned here/Engine. | +| Existing capture pattern | `tools/standards_engine/standards_engine/consumer_authoring.py` | bind_sources/captured_sources | Reference ownership precedent only; do not make consumer registration a generic evidence resolver. | +| New bound material owner | `tools/standards_engine/standards_engine/evidence_bindings.py` | new, A2 | Narrow acquisition, canonical bundle, lifecycle/export and origin inspection. No generic plugin registry. | +| Transport/canonical contracts | `tools/standards_engine/contracts/a1-contract.schema.json` | EvidenceReference, Apply/Recover/Workflow/Preview and proposed new calls | Keep current four-field evidence carrier; introduce bounded explicit public result/action variants at current schema owner. | +| Interface/generation | `tools/standards_engine/contracts/a1-interface.toml` | interface 45, request6/result7 | Allocate next actual release edition; regenerate _generated_contract.py and generated/agent-tools.json atomically. | +| Publication and evidence tests | `tools/standards_engine/tests/test_coverage_publication.py` | entire existing integration | Retain late evidence tampering and cold-clone verification; add changed-candidate evidence pre-readiness path. | +| Recovery tests | `tools/standards_engine/tests/test_publication_recovery.py` | entire existing fault fixture | Preserve never-republish-after-applied, selected application and current target checks. | +| Decision/purpose tests | `tools/standards_engine/tests/test_agent_workflow.py` | focused revision/status | Test intended source of prior Analysis and final-review separation. | +| New evidence/reconcile cases | `tools/standards_engine/tests/test_authoring_evidence_bindings.py` | new, A2 | Real capture/resolver/export/legacy/cold receipt and no-authority from evidence presence. | +| New reconciliation cases | `tools/standards_engine/tests/test_checkout_reconciliation.py` | new, A3 | Exact bytes/staging and interruption behavior in disposable Git/SQLite processes. | +| Existing baseline fixture | `tools/standards_engine/tests/test_supporting_workflow.py` | 78–86 and setup | Replace real topic.security assumption with test-owned exposure; direct wrapper in test_process_reuse.py stays coherent. | +| Authoring instructions | `.agents/skills/standards-engine/references/authoring.md` | publication/evidence task flow | Explain applied-versus-checkout, explicit binding/export, fresh final review, recovery versus reconciliation. | +| Entry guidance | `.agents/skills/standards-engine/SKILL.md` | result states and exact handles | Coordinate small current task examples; avoid repeating normative rules or restoring eager schemas. | +| Public docs | `tools/standards_engine/PURPOSE-SEPARATION.md` | authoring and retained contracts | Record authorized diagnostic split, actual version cutover and supported local mutation threat model. | +| Verification inputs | `evaluation/standards-effectiveness/generated/suite-inputs.json` | producer generated | Refresh only through the existing owner when implementation changes captured inputs. | + +## Version/persistence facts + +EvidenceReference currently has exactly id/digest/provider_contract/provider_contract_version. +Local facade resolution is working-tree repository-content@1; coverage publication +and published receipt replay independently demand destination bytes. Proposal +readiness schema1 and application schema1 are retained records, not display DTOs. +Authoring contract2 and request contract6 are retained. Result projection7 is the +previous output edition; this release adds result projection8. +Public interface46 is the reviewed candidate edition; installed interface45 clients +must reconnect and reload the interface46 schema after deployment. There is no +interface45 output compatibility mode. In-repository generated contracts, examples, +tests, and configured harnesses are updated together. The running MCP instance +remains on interface45 because it is bound to the separately dirty main checkout; +it was not restarted or served A1 source. Application/readiness persistence schemas +are unchanged and the cold status read remains covered. + +Bound bundles deliberately add independent material rather than change old reference +meaning. New aggregate kinds must explicitly declare identity, retention, root +dependencies and failure cleanup. Reconciliation observations are transient unless +a durable intent is required for partial-effect recovery; that intent does not +become a second publication record. Existing coverage v1 loader support remains. + +## Delivery consumers + +Reconcile installed authoring registrations and existing native/agent test harnesses +with each actual new interface edition. No provider networking or registration +change is part of this planning task. Keep application-purpose catalogs restricted. +A new action may require a specifically authorized capability; availability does +not imply the user authorized a checkout mutation or exporting imported evidence. + +Generated examples in contracts/examples/a1-examples.json, contract/schema tests, +request-evidence normalization, mcp_catalog descriptions, operation inventory, CLI +reference invocation and configured Codex qualification harnesses are direct +consumers of public additions. Do not broaden all of them unless the selected +slice actually changes their inputs or outputs. Historic traces retain their original +source/catalog and verdict; no backdated migration is performed. diff --git a/evaluation/standards-effectiveness/generated/suite-inputs.json b/evaluation/standards-effectiveness/generated/suite-inputs.json index 733f6d71..565eb046 100644 --- a/evaluation/standards-effectiveness/generated/suite-inputs.json +++ b/evaluation/standards-effectiveness/generated/suite-inputs.json @@ -875,7 +875,7 @@ ] }, { - "digest": "sha256:8bb1377a2a91ab41bb7cffc22172a3691753600ffccbf1454c02132819bfbbb9", + "digest": "sha256:4976e96dbccec0b90b21a014c2e660749062842e3c39c589d0174e55f8bbdf8e", "path": "docs/plans/README.md", "state": "present", "uses": [ @@ -6573,7 +6573,7 @@ ] }, { - "digest": "sha256:18e319b80913da723351b6135aa0e24da3df461803fd8d40a530eef343e40c11", + "digest": "sha256:c0c8001952d1f914f263e243193a56c97fd4600d51a5c0a4157133ffece83562", "path": "tools/repository_git/repository_git/__init__.py", "state": "present", "uses": [ @@ -6636,7 +6636,7 @@ ] }, { - "digest": "sha256:95f201111583e2c57988f0cf705b2fdf8ed1e4508b674329adde674494aa9c10", + "digest": "sha256:c0869a4d1a803a0c24c6e87cdd78fb0fc5a6d3801e59402017ea597f09cc577c", "path": "tools/repository_git/repository_git/repository.py", "state": "present", "uses": [ @@ -6653,7 +6653,7 @@ ] }, { - "digest": "sha256:d93709cd96174542afefa646c8aa80cb01476eaec3c3a2e489f250f361a9bbcf", + "digest": "sha256:2ee478c8908bfbd7d303add9a2ce0801251d3a421da61c62513593d9b75128b1", "path": "tools/repository_git/tests/test_repository.py", "state": "present", "uses": [ @@ -6778,7 +6778,7 @@ ] }, { - "digest": "sha256:ec35fe406cffa9837695ed58851d04845570c78de1da424956c1627cea01d892", + "digest": "sha256:907a27607f06fd1b0f7a2e839eba5f089840861c06f8ee38e771526c9c0d2518", "path": "tools/standards_analysis/standards_analysis/__init__.py", "state": "present", "uses": [ @@ -6824,7 +6824,7 @@ ] }, { - "digest": "sha256:d5150121982b0c808abac8d2688a164e7df54906ab5b999b7b66e01f0b527f5e", + "digest": "sha256:1fecafc49b9adb5516925398fdeec516e1c8cc6ae5240f7b67d329795fe50730", "path": "tools/standards_analysis/standards_analysis/coverage_publication.py", "state": "present", "uses": [ @@ -6841,7 +6841,7 @@ ] }, { - "digest": "sha256:b676512f497b0c0c832efa841390c55da6dd3171f6975965b4a1be48477c74f1", + "digest": "sha256:2381dbb0d02c118196899213970ce61053e69b30a190ad830532e13fc5fa38ff", "path": "tools/standards_analysis/standards_analysis/errors.py", "state": "present", "uses": [ @@ -6984,7 +6984,7 @@ ] }, { - "digest": "sha256:7e8009e9d9781bf06acac93ba9c8956c1b6a0547578a86297249efafdee3b1ad", + "digest": "sha256:e4d6f239e18682a3208d1c8a128ec602cbac0ad79b3bf1b726386cc9db6761de", "path": "tools/standards_analysis/standards_analysis/trust.py", "state": "present", "uses": [ @@ -7243,7 +7243,7 @@ ] }, { - "digest": "sha256:1830c10093341b407f8568296c0b7a964f4733323f05947f6a072607c20f2050", + "digest": "sha256:ebee8cc5b4d4e7bc2d6b6a89c6ea8d4f5b6ce5d6d135e629dbfb67cbede347a9", "path": "tools/standards_engine/README.md", "state": "present", "uses": [ @@ -7255,7 +7255,7 @@ ] }, { - "digest": "sha256:95fc8909d3c37e27b41866a3e048218ca514c63ac02b4d0f8746ab2c511e07d0", + "digest": "sha256:065f284eeee398b764c8eebf151fec59727e3b0b1dad1fea942607129a110335", "path": "tools/standards_engine/contracts/README.md", "state": "present", "uses": [ @@ -7267,7 +7267,7 @@ ] }, { - "digest": "sha256:21be68f7b275a63d5de852d2590b1449f69259bc0b77f8df1cb3bb1eac5e7ace", + "digest": "sha256:4b47d716588fb52b025dd97e6081dbf2d12b00de201f2f5ca3f48e5709814c45", "path": "tools/standards_engine/contracts/a1-contract.schema.json", "state": "present", "uses": [ @@ -7284,7 +7284,7 @@ ] }, { - "digest": "sha256:28f918a1f70e3bfe7d001f3fc1fde3259954c3369ec13f5479aa92637b45546e", + "digest": "sha256:9621bae4721e4ef0104db5041e96fcdb342276106679da5daa4e38df0b267b99", "path": "tools/standards_engine/contracts/a1-interface.toml", "state": "present", "uses": [ @@ -7301,7 +7301,7 @@ ] }, { - "digest": "sha256:ed74ce3a5fabd8fb3aed0b1cb89993f8062ed1eda351819cbfe3c6031bcb1b28", + "digest": "sha256:889c0ddcd1105f8f741a586460d913c55dc15c03c3cc1627b8f914434878240e", "path": "tools/standards_engine/contracts/examples/a1-examples.json", "state": "present", "uses": [ @@ -7318,7 +7318,7 @@ ] }, { - "digest": "sha256:329ae7ac6a0f7363c8f9266b6608ebfef882432e9d2e0083d2a839b19e90383b", + "digest": "sha256:b675b7fb1383ea1687ab85bb96cfa1082a1561985901bef9a544b446417a5dff", "path": "tools/standards_engine/contracts/generated/agent-tools.json", "state": "present", "uses": [ @@ -7381,7 +7381,7 @@ ] }, { - "digest": "sha256:af70a74f6f00ffccffcb378dfe9aad4c30626edecc27c1ad408f7d1afc135797", + "digest": "sha256:fad80e42005503a1b24e4a1ac458d8d6f91fbf48e2797b7812858b903e52e8c5", "path": "tools/standards_engine/standards_engine/_generated_contract.py", "state": "present", "uses": [ @@ -7415,7 +7415,7 @@ ] }, { - "digest": "sha256:5d64103d7e5d617c180b14eb7eaf2735fb97b97198645a0be70fbe010a28e60b", + "digest": "sha256:9a39d95363aec431a62fa4dbced44ed4f3d87f9b4a302852a18b4396dad5d5d9", "path": "tools/standards_engine/standards_engine/agent_workflow.py", "state": "present", "uses": [ @@ -7511,7 +7511,7 @@ ] }, { - "digest": "sha256:983b8c6c2a0e97eba000a80568ecb2277240f282b61061d996b4f0e4b0425bcb", + "digest": "sha256:02e5bb8cbef1cbcd836a0f707d4db495b3f42a211fe140b8a04d01da268aded4", "path": "tools/standards_engine/standards_engine/engine.py", "state": "present", "uses": [ @@ -7759,7 +7759,7 @@ ] }, { - "digest": "sha256:4be3f0d6d9c0d6dcae1755556144482b086d1f67e6a6acfedaee5648bce1b31b", + "digest": "sha256:c463c48d95bcbc5b5bfd3690668198897a251c5000e59db71f2cbc5f983d71af", "path": "tools/standards_engine/tests/test_analysis.py", "state": "present", "uses": [ @@ -7771,7 +7771,7 @@ ] }, { - "digest": "sha256:b86ec551134d8760de50c59666b10d91b4a9e03311e4b85bb14614c279780f3e", + "digest": "sha256:2a5e6761f159c63e3c79f8fed0d90e1edcf987ea78a86fc9878a2866c840ef03", "path": "tools/standards_engine/tests/test_coverage_publication.py", "state": "present", "uses": [ @@ -13948,7 +13948,7 @@ "path": "evaluation/standards-effectiveness/suite-registry.toml" }, "repository_index": { - "digest": "sha256:e5b6c59d68560c738ccdb778b3a76441c0f28db4c1705ec83c0cef03e19cf534", + "digest": "sha256:3ac80691ed48a9cb64259131ccd41300d431c1e8605f9c94a2dbfb51cad1ea1c", "uses": [ { "check": "python-package-contract", diff --git a/tools/repository_git/README.md b/tools/repository_git/README.md index bf72b64e..c49b0234 100644 --- a/tools/repository_git/README.md +++ b/tools/repository_git/README.md @@ -45,6 +45,17 @@ promisor fetching and replace-object interpretation for that call. Callers still select fixed read-only Git arguments; the option does not authorize helpers, filters, checkout, or repository mutation. `revision_tree` returns the exact tree object ID for a selected commit. + +`observe_publication_checkout(expected, candidate)` compares the selected +checkout's symbolic branch, HEAD, index and worktree against only the paths that +differ between the two exact commits. It returns separate predecessor, candidate +and conflict counts for index and worktree paths, a bounded index observation +digest, and one of `not-target-checkout`, `current`, `needs-reconciliation`, or +`conflicted`. Unrelated changes are excluded from the path counts. The operation +uses local-only Git reads, no-follow filesystem inspection, and does not write the +checkout, index, refs, or object database. Unsupported index or file layouts and +stale observations fail explicitly for the caller to report as unavailable. + For a commit-to-commit patch, `git_output(..., attribute_source=revision)` pins Git attribute lookup to the selected commit, so dirty worktree attributes cannot change how its complete binary patch is represented. diff --git a/tools/repository_git/repository_git/__init__.py b/tools/repository_git/repository_git/__init__.py index 932692bb..f56cda9c 100644 --- a/tools/repository_git/repository_git/__init__.py +++ b/tools/repository_git/repository_git/__init__.py @@ -14,6 +14,7 @@ COMMAND_TIMEOUT_SECONDS, DEFAULT_OUTPUT_LIMIT, GitRepository, + PublicationCheckoutObservation, RevisionReadSession, git_command, git_output, @@ -33,6 +34,7 @@ "GitCommandResult", "GitCommandObservation", "GitRepository", + "PublicationCheckoutObservation", "RevisionReadSession", "GitRepositoryError", "GitRepositoryFailure", diff --git a/tools/repository_git/repository_git/repository.py b/tools/repository_git/repository_git/repository.py index 2f322693..1e193787 100644 --- a/tools/repository_git/repository_git/repository.py +++ b/tools/repository_git/repository_git/repository.py @@ -1,5 +1,6 @@ from __future__ import annotations +import errno import hashlib import os import stat @@ -42,6 +43,29 @@ DEFAULT_REVISION_CACHE_OBJECTS = 1024 +@dataclass(frozen=True, slots=True) +class PublicationCheckoutObservation: + """Read-only observation of one checkout against an admitted publication.""" + + worktree_id: str + symbolic_branch: str | None + head: RepositoryRevision + index_digest: str + publication_path_count: int + index_predecessor_count: int + index_candidate_count: int + index_conflict_count: int + worktree_predecessor_count: int + worktree_candidate_count: int + worktree_conflict_count: int + status: Literal[ + "not-target-checkout", "current", "needs-reconciliation", "conflicted" + ] + + +_PublicationEntry = tuple[str, str] | None + + def sanitized_git_environment() -> dict[str, str]: selected = { key: value @@ -226,6 +250,7 @@ def __init__( self._gitlinks = {item.prefix.components: item.repository for item in selected} self._max_object_bytes = max_object_bytes self._active_candidates: set[int] = set() + self._candidate_roots: dict[int, MaterializedCandidate] = {} @property def root(self) -> Path: @@ -235,7 +260,9 @@ def root(self) -> Path: def current_revision(self) -> RepositoryRevision: return self._revision("HEAD^{commit}") - def branch_revision(self, branch: str) -> RepositoryRevision: + def branch_revision( + self, branch: str, *, local_only: bool = False + ) -> RepositoryRevision: if ( type(branch) is not str or not branch @@ -259,7 +286,218 @@ def branch_revision(self, branch: str) -> RepositoryRevision: "REPOSITORY_GIT.INVALID_BRANCH", "branch name is not canonical", ) - return self._revision(f"refs/heads/{branch}^{{commit}}") + return self._revision( + f"refs/heads/{branch}^{{commit}}", local_only=local_only + ) + + def observe_publication_checkout( + self, + expected: RepositoryRevision, + candidate: RepositoryRevision, + target_ref: str = "refs/heads/main", + ) -> PublicationCheckoutObservation: + """Observe publication paths in this checkout without changing Git state. + + Only paths whose exact tree entries differ between ``expected`` and + ``candidate`` contribute to the agreement counts. Unrelated index, + worktree, and untracked changes remain outside those counts. + """ + if type(expected) is not RepositoryRevision or type(candidate) is not RepositoryRevision: + raise invalid( + "REPOSITORY_GIT.INVALID_REVISION", + "publication observation requires exact predecessor and candidate revisions", + ) + if ( + type(target_ref) is not str + or not target_ref + or "\0" in target_ref + or any(0xD800 <= ord(character) <= 0xDFFF for character in target_ref) + ): + raise invalid("REPOSITORY_GIT.INVALID_REF", "target ref must be a full canonical Git ref") + checked_ref = git_command( + self._repository, ("check-ref-format", target_ref), + max_output_bytes=256, local_only=True, + ) + if checked_ref.returncode != 0: + raise invalid("REPOSITORY_GIT.INVALID_REF", "target ref is not canonical") + target_revision = self._revision( + f"{target_ref}^{{commit}}", local_only=True + ) + + initial_bindings = self._publication_checkout_bindings() + worktree, git_directory, common_directory = initial_bindings + administrative_descriptors: list[tuple[Path, int]] = [] + try: + # Pin both administrative roots before reading HEAD, trees, or the + # index: matching paths and Git contents cannot prove inode identity. + for directory in dict.fromkeys((git_directory, common_directory)): + descriptor = _open_absolute_directory(directory) + administrative_descriptors.append((directory, descriptor)) + identity = hashlib.sha256( + b"coding-standards:publication-worktree:v1\0" + + b"\0".join(os.fsencode(path) for path in (worktree, git_directory, common_directory)) + ).hexdigest() + + symbolic_branch = self._symbolic_head() + head = self._revision("HEAD^{commit}", local_only=True) + if symbolic_branch == target_ref and head != target_revision: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "target ref and HEAD differed at observation start") + + predecessor_entries = self.revision_entries(expected, local_only=True) + try: + candidate_entries = self.revision_entries(candidate, local_only=True) + except GitRepositoryError as error: + if error.failure.kind != "unavailable": + raise + active = next( + (item for item in self._candidate_roots.values() if item.revision == candidate), + None, + ) + if active is None: + raise + candidate_entries = GitRepository( + active.root, max_object_bytes=self._max_object_bytes + ).revision_entries(candidate, local_only=True) + paths = tuple(sorted( + path for path in predecessor_entries.keys() | candidate_entries.keys() + if predecessor_entries.get(path) != candidate_entries.get(path) + )) + changed_entries = tuple( + entry + for path in paths + for entry in (predecessor_entries.get(path), candidate_entries.get(path)) + if entry is not None + ) + for entry in changed_entries: + if entry[0] not in {"100644", "100755", "120000"}: + if entry[0] == "160000": + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_PUBLICATION_MODE", "publication observation does not inspect gitlinks") + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_PUBLICATION_MODE", "publication tree contains an unsupported mode") + + index_entries, unmerged, index_digest = _publication_index_observation(self._repository) + if any(mode in {"040000", "40000"} for mode, _ in index_entries.values()) or _index_has_skipped_paths(self._repository): + raise unsupported( + "REPOSITORY_GIT.UNSUPPORTED_INDEX_LAYOUT", + "publication observation does not support sparse or skip-worktree indexes", + ) + index_predecessor = index_candidate = index_conflicts = 0 + worktree_predecessor = worktree_candidate = worktree_conflicts = 0 + worktree_fd = _open_absolute_directory(worktree) + retained_descriptors: list[int] = [] + retained_bindings: list[tuple[int, bytes, os.stat_result]] = [] + try: + for path in paths: + key = str(path) + if key in unmerged: + index_conflicts += 1 + else: + observed_index = index_entries.get(key) + if observed_index == predecessor_entries.get(path): + index_predecessor += 1 + elif observed_index == candidate_entries.get(path): + index_candidate += 1 + else: + index_conflicts += 1 + if _worktree_entry_matches( + worktree_fd, path, predecessor_entries.get(path), self._max_object_bytes, + retained_descriptors=retained_descriptors, retained_bindings=retained_bindings, + ): + worktree_predecessor += 1 + elif _worktree_entry_matches( + worktree_fd, path, candidate_entries.get(path), self._max_object_bytes, + retained_descriptors=retained_descriptors, retained_bindings=retained_bindings, + ): + worktree_candidate += 1 + else: + worktree_conflicts += 1 + # An unmerged entry outside the publication paths still makes the + # selected index conflicted, even though it does not inflate counts. + target_checkout = symbolic_branch == target_ref + if unmerged: + status = "conflicted" + elif not target_checkout: + status = "not-target-checkout" + elif index_conflicts > 0 or worktree_conflicts > 0: + status = "conflicted" + elif ( + (head == expected and index_predecessor == len(paths) and worktree_predecessor == len(paths)) + or (head == candidate and index_candidate == len(paths) and worktree_candidate == len(paths)) + ): + status = "current" + else: + status = "needs-reconciliation" + + # Reject a torn observation if HEAD or the index moved while paths were + # being inspected. This remains read-only and gives callers a retryable + # unavailable outcome rather than mixed facts. + if self._symbolic_head() != symbolic_branch: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "symbolic HEAD changed during publication observation") + if self._revision("HEAD^{commit}", local_only=True) != head: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "HEAD changed during publication observation") + if self._revision(f"{target_ref}^{{commit}}", local_only=True) != target_revision: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "target ref changed during publication observation") + _, after_unmerged, after_digest = _publication_index_observation(self._repository) + if after_digest != index_digest or after_unmerged != unmerged: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "index changed during publication observation") + + if self._publication_checkout_bindings() != initial_bindings: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "checkout directories changed during publication observation") + for directory, descriptor in administrative_descriptors: + _verify_absolute_directory_binding(directory, descriptor) + _verify_absolute_directory_binding(worktree, worktree_fd) + _verify_directory_chain(retained_bindings) + + return PublicationCheckoutObservation( + identity, symbolic_branch, head, index_digest, len(paths), + index_predecessor, index_candidate, index_conflicts, + worktree_predecessor, worktree_candidate, worktree_conflicts, status, + ) + + finally: + for descriptor in reversed(retained_descriptors): + os.close(descriptor) + os.close(worktree_fd) + + finally: + for _, descriptor in reversed(administrative_descriptors): + os.close(descriptor) + + def _publication_checkout_bindings(self) -> tuple[Path, Path, Path]: + controls = self.control_directories(local_only=True) + if not controls: + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_LAYOUT", "Git did not report administrative directories") + git_directory, common_directory = controls[0], controls[-1] + top_output = git_output( + self._repository, ("rev-parse", "--show-toplevel"), + max_output_bytes=4096, local_only=True, + ) + worktree = _decode_absolute_git_path(top_output, "worktree root") + try: + worktree = worktree.resolve(strict=True) + git_directory = git_directory.resolve(strict=True) + common_directory = common_directory.resolve(strict=True) + except OSError as error: + raise unavailable("REPOSITORY_GIT.WORKTREE_UNAVAILABLE", "worktree identity could not be observed") from error + return worktree, git_directory, common_directory + + def _symbolic_head(self) -> str | None: + symbolic = git_command( + self._repository, + ("symbolic-ref", "--quiet", "HEAD"), + max_output_bytes=4096, + local_only=True, + ) + if symbolic.returncode == 0: + try: + value = symbolic.stdout.decode("utf-8").removesuffix("\n") + except UnicodeError as error: + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_PATH", "symbolic branch encoding is unsupported") from error + if not value or "\n" in value or "\0" in value: + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_LAYOUT", "symbolic HEAD is not one branch ref") + return value + if symbolic.returncode == 1: + return None + raise _failed_command(("symbolic-ref",), symbolic) def revision_paths( self, revision: RepositoryRevision @@ -623,10 +861,12 @@ def materialize_candidate( self._validate_candidate(candidate) identity = id(candidate) self._active_candidates.add(identity) + self._candidate_roots[identity] = candidate try: yield candidate finally: self._active_candidates.discard(identity) + self._candidate_roots.pop(identity, None) def publish_candidate( self, @@ -864,11 +1104,14 @@ def _validate_candidate(self, candidate: MaterializedCandidate) -> None: f"candidate path {path!r} differs from its object", ) - def _revision(self, revision: str) -> RepositoryRevision: + def _revision( + self, revision: str, *, local_only: bool = False + ) -> RepositoryRevision: output = git_output( self._repository, ("rev-parse", "--verify", "--end-of-options", revision), max_output_bytes=256, + local_only=local_only, ) try: oid = output.decode("ascii").strip() @@ -1306,6 +1549,258 @@ def _index_entries(root: Path) -> dict[str, tuple[str, str]]: return entries +def _decode_absolute_git_path(raw: bytes, description: str) -> Path: + try: + value = raw.decode("utf-8") + except UnicodeError as error: + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_PATH", f"{description} encoding is unsupported") from error + if not value.endswith("\n") or "\n" in value[:-1] or "\0" in value: + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_PATH", f"{description} is not one canonical path") + path = Path(value[:-1]) + if not path.is_absolute(): + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_LAYOUT", f"{description} is not absolute") + return path + + +def _publication_index_observation( + root: Path, +) -> tuple[dict[str, tuple[str, str]], frozenset[str], str]: + """Read every index stage without asking Git to write or normalize a tree.""" + raw = git_output(root, ("ls-files", "--stage", "-z"), local_only=True) + entries: dict[str, tuple[str, str]] = {} + unmerged: set[str] = set() + for field in raw.split(b"\0"): + if not field: + continue + header, separator, raw_path = field.partition(b"\t") + parts = header.split(b" ") + if not separator or len(parts) != 3: + raise invalid("REPOSITORY_GIT.INVALID_OUTPUT", "Git index observation is malformed") + try: + mode = parts[0].decode("ascii") + oid = parts[1].decode("ascii") + stage = int(parts[2]) + path = raw_path.decode("utf-8") + RepositoryPath.parse(path) + RepositoryRevision(oid) + except (UnicodeError, ValueError, GitRepositoryError) as error: + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_INDEX", "Git index entry is not supported") from error + if stage not in (0, 1, 2, 3): + raise invalid("REPOSITORY_GIT.INVALID_OUTPUT", "Git index stage is outside the supported range") + if stage: + unmerged.add(path) + elif path in entries: + raise invalid("REPOSITORY_GIT.INVALID_OUTPUT", "Git index repeats a stage-zero path") + else: + entries[path] = (mode, oid) + if raw and not raw.endswith(b"\0"): + raise invalid("REPOSITORY_GIT.INVALID_OUTPUT", "Git index observation is unterminated") + digest = hashlib.sha256(b"coding-standards:git-index-observation:v1\0" + raw).hexdigest() + return entries, frozenset(unmerged), digest + + +def _index_has_skipped_paths(root: Path) -> bool: + raw = git_output(root, ("ls-files", "-t", "-z"), local_only=True) + for field in raw.split(b"\0"): + if field and field[:2] == b"S ": + return True + return False + + +def _worktree_entry_matches( + root_fd: int, path: RepositoryPath, entry: _PublicationEntry, max_object_bytes: int, + *, retained_descriptors: list[int], + retained_bindings: list[tuple[int, bytes, os.stat_result]], +) -> bool: + """Compare one path through pinned directory descriptors and no-follow opens.""" + if not _supports_safe_dirfd_observation(): + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_PLATFORM", "safe directory-relative observation is unavailable") + try: + descriptors = [os.dup(root_fd)] + except OSError as error: + raise unavailable("REPOSITORY_GIT.WORKTREE_UNAVAILABLE", "worktree descriptor could not be retained") from error + bindings: list[tuple[int, bytes, os.stat_result]] = [] + try: + parent_fd = descriptors[0] + directory_flags = os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | getattr(os, "O_CLOEXEC", 0) + for component in path.components[:-1]: + name = os.fsencode(component) + try: + child_fd = os.open(name, directory_flags, dir_fd=parent_fd) + except FileNotFoundError: + _verify_directory_chain(bindings) + return entry is None + except OSError as error: + if error.errno in {errno.ELOOP, errno.ENOTDIR}: + raise unsupported( + "REPOSITORY_GIT.UNSUPPORTED_WORKTREE_LAYOUT", + "publication observation does not follow symbolic-link ancestors", + ) from error + raise unavailable("REPOSITORY_GIT.WORKTREE_UNAVAILABLE", "publication directory could not be opened safely") from error + descriptors.append(child_fd) + try: + child_info = os.fstat(child_fd) + except OSError as error: + raise unavailable("REPOSITORY_GIT.WORKTREE_UNAVAILABLE", "publication directory could not be inspected safely") from error + try: + visible = os.stat(name, dir_fd=parent_fd, follow_symlinks=False) + except OSError as error: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "publication directory moved during observation") from error + if not stat.S_ISDIR(visible.st_mode) or not _same_file_identity(child_info, visible): + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "publication directory changed during observation") + bindings.append((parent_fd, name, child_info)) + parent_fd = child_fd + + leaf = os.fsencode(path.components[-1]) + try: + before = os.stat(leaf, dir_fd=parent_fd, follow_symlinks=False) + except FileNotFoundError: + _verify_directory_chain(bindings) + return entry is None + except OSError as error: + raise unavailable("REPOSITORY_GIT.WORKTREE_UNAVAILABLE", "publication path could not be observed") from error + if entry is None: + _verify_directory_chain(bindings) + return False + mode, oid = entry + if mode == "120000": + if not stat.S_ISLNK(before.st_mode): + _verify_directory_chain(bindings) + return False + try: + content = os.readlink(leaf, dir_fd=parent_fd) + after = os.stat(leaf, dir_fd=parent_fd, follow_symlinks=False) + except OSError as error: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "publication symlink changed during observation") from error + _verify_directory_chain(bindings) + if len(content) > max_object_bytes: + raise unsupported("REPOSITORY_GIT.PUBLICATION_OBJECT_LIMIT", "publication symlink exceeds the observation bound") + return _same_file_observation(before, after) and hashlib.new( + _algorithm(oid), f"blob {len(content)}\0".encode("ascii") + content + ).hexdigest() == oid + if mode not in {"100644", "100755"} or not stat.S_ISREG(before.st_mode): + _verify_directory_chain(bindings) + return False + if bool(before.st_mode & 0o111) != (mode == "100755"): + _verify_directory_chain(bindings) + return False + flags = os.O_RDONLY | os.O_NOFOLLOW | getattr(os, "O_CLOEXEC", 0) | getattr(os, "O_NONBLOCK", 0) + try: + descriptor = os.open(leaf, flags, dir_fd=parent_fd) + try: + opened = os.fstat(descriptor) + if not stat.S_ISREG(opened.st_mode): + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "publication file type changed during observation") + if opened.st_size > max_object_bytes: + raise unsupported("REPOSITORY_GIT.PUBLICATION_OBJECT_LIMIT", "publication file exceeds the observation bound") + digest = hashlib.new(_algorithm(oid)) + digest.update(f"blob {opened.st_size}\0".encode("ascii")) + size = 0 + while True: + chunk = os.read(descriptor, 1024 * 1024) + if not chunk: + break + size += len(chunk) + if size > max_object_bytes: + raise unsupported("REPOSITORY_GIT.PUBLICATION_OBJECT_LIMIT", "publication file exceeds the observation bound") + digest.update(chunk) + finally: + os.close(descriptor) + after = os.stat(leaf, dir_fd=parent_fd, follow_symlinks=False) + except OSError as error: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "publication file changed during observation") from error + _verify_directory_chain(bindings) + if not _same_file_observation(before, opened) or not _same_file_observation(before, after): + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "publication file changed during observation") + return size == before.st_size and digest.hexdigest() == oid + finally: + # Keep every touched ancestor pinned until the observer finishes its + # Git rechecks and validates all directory bindings together. + retained_descriptors.extend(descriptors) + retained_bindings.extend(bindings) + + +def _supports_safe_dirfd_observation() -> bool: + return ( + hasattr(os, "O_DIRECTORY") + and hasattr(os, "O_NOFOLLOW") + and os.open in os.supports_dir_fd + and os.stat in os.supports_dir_fd + and os.readlink in os.supports_dir_fd + and os.stat in os.supports_follow_symlinks + ) + + +def _open_absolute_directory(path: Path) -> int: + if not _supports_safe_dirfd_observation(): + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_PLATFORM", "safe directory-relative observation is unavailable") + if not path.is_absolute() or any(part in {".", ".."} for part in path.parts): + raise unsupported("REPOSITORY_GIT.UNSUPPORTED_LAYOUT", "worktree root is not a canonical absolute path") + flags = os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | getattr(os, "O_CLOEXEC", 0) + try: + descriptor = os.open(os.fsencode(path.anchor), flags) + except OSError as error: + raise unavailable("REPOSITORY_GIT.WORKTREE_UNAVAILABLE", "worktree directory could not be opened safely") from error + owned_descriptors = [descriptor] + try: + for component in path.parts[1:]: + next_descriptor = os.open(os.fsencode(component), flags, dir_fd=descriptor) + owned_descriptors.append(next_descriptor) + os.close(descriptor) + owned_descriptors.remove(descriptor) + descriptor = next_descriptor + owned_descriptors.remove(descriptor) + return descriptor + except OSError as error: + raise unavailable("REPOSITORY_GIT.WORKTREE_UNAVAILABLE", "worktree directory could not be opened safely") from error + finally: + for owned_descriptor in reversed(owned_descriptors): + try: + os.close(owned_descriptor) + except OSError: + pass + + +def _verify_absolute_directory_binding(path: Path, descriptor: int) -> None: + try: + replacement = _open_absolute_directory(path) + except GitRepositoryError as error: + if error.failure.kind != "unavailable": + raise + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "checkout directory moved during observation") from error + try: + if not _same_file_identity(os.fstat(descriptor), os.fstat(replacement)): + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "checkout directory changed during observation") + finally: + os.close(replacement) + + +def _verify_directory_chain(bindings: list[tuple[int, bytes, os.stat_result]]) -> None: + for parent_fd, name, opened in bindings: + try: + current = os.stat(name, dir_fd=parent_fd, follow_symlinks=False) + except OSError as error: + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "publication directory moved during observation") from error + if not stat.S_ISDIR(current.st_mode) or not _same_file_identity(opened, current): + raise unavailable("REPOSITORY_GIT.OBSERVATION_STALE", "publication directory changed during observation") + + +def _same_file_identity(left: os.stat_result, right: os.stat_result) -> bool: + return ( + left.st_dev, left.st_ino, stat.S_IFMT(left.st_mode) + ) == ( + right.st_dev, right.st_ino, stat.S_IFMT(right.st_mode) + ) + + +def _same_file_observation(left: os.stat_result, right: os.stat_result) -> bool: + return ( + left.st_dev, left.st_ino, left.st_mode, left.st_size, left.st_mtime_ns + ) == ( + right.st_dev, right.st_ino, right.st_mode, right.st_size, right.st_mtime_ns + ) + + def _validate_candidate_topology( entries: dict[str, tuple[str, str]], files: tuple[CandidateFile, ...], diff --git a/tools/repository_git/tests/test_repository.py b/tools/repository_git/tests/test_repository.py index f4ff0636..74e2a260 100644 --- a/tools/repository_git/tests/test_repository.py +++ b/tools/repository_git/tests/test_repository.py @@ -1,6 +1,8 @@ from __future__ import annotations +import errno import os +import shutil import subprocess import tempfile import unittest @@ -107,6 +109,516 @@ def test_branch_revision_is_independent_of_the_checked_out_head(self) -> None: self.assertNotEqual(repository.current_revision().oid, main) self.assertEqual(repository.branch_revision("main").oid, main) + def test_publication_checkout_observes_ref_advance_without_checkout_writes(self) -> None: + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) + self._initialize(root) + (root / "value.txt").write_bytes(b"predecessor\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + repository = GitRepository(root) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + objects_before = self._git(root, "count-objects", "-v") + ref_before = self._git(root, "rev-parse", "refs/heads/main") + index_before = self._git(root, "ls-files", "--stage", "-z") + before = repository.observe_publication_checkout(expected, candidate.revision) + self.assertEqual(before.status, "current") + self.assertEqual(before.symbolic_branch, "refs/heads/main") + self.assertEqual(before.head, expected) + self.assertEqual(before.publication_path_count, 1) + self.assertEqual(before.index_predecessor_count, 1) + self.assertEqual(before.worktree_predecessor_count, 1) + self.assertRegex(before.worktree_id, r"[0-9a-f]{64}") + self.assertEqual(before.worktree_id, repository.observe_publication_checkout( + expected, candidate.revision + ).worktree_id) + self.assertEqual(self._git(root, "count-objects", "-v"), objects_before) + self.assertEqual(self._git(root, "rev-parse", "refs/heads/main"), ref_before) + self.assertEqual(self._git(root, "ls-files", "--stage", "-z"), index_before) + self.assertEqual((root / "value.txt").read_bytes(), b"predecessor\n") + + self.assertEqual(repository.publish_candidate(candidate, expected), "updated") + after_ref = repository.observe_publication_checkout(expected, candidate.revision) + self.assertEqual(after_ref.status, "needs-reconciliation") + self.assertEqual(after_ref.head, candidate.revision) + self.assertEqual(after_ref.index_predecessor_count, 1) + self.assertEqual(after_ref.worktree_predecessor_count, 1) + self.assertEqual((root / "value.txt").read_bytes(), b"predecessor\n") + self.assertEqual(self._git(root, "ls-files", "-s"), + "100644 " + self._git(root, "rev-parse", "HEAD^:value.txt").strip() + + " 0\tvalue.txt\n") + + self._git(root, "reset", "--hard", candidate.revision.oid) + after_checkout = repository.observe_publication_checkout(expected, candidate.revision) + self.assertEqual(after_checkout.status, "current") + self.assertEqual(after_checkout.index_candidate_count, 1) + self.assertEqual(after_checkout.worktree_candidate_count, 1) + + def test_publication_checkout_ignores_and_preserves_unrelated_changes(self) -> None: + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) + self._initialize(root) + (root / "value.txt").write_bytes(b"predecessor\n") + (root / "other.txt").write_bytes(b"committed\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + repository = GitRepository(root) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + self.assertEqual(repository.publish_candidate(candidate, expected), "updated") + (root / "staged.txt").write_bytes(b"unrelated staged\n") + self._git(root, "add", "staged.txt") + (root / "other.txt").write_bytes(b"unrelated unstaged\n") + (root / "untracked.txt").write_bytes(b"unrelated untracked\n") + index_before = self._git(root, "ls-files", "--stage", "-z") + status_before = subprocess.run( + ("git", "-C", str(root), "status", "--porcelain=v1", "-z"), + check=True, stdout=subprocess.PIPE, + ).stdout + observation = repository.observe_publication_checkout(expected, candidate.revision) + self.assertEqual(observation.status, "needs-reconciliation") + self.assertEqual(observation.publication_path_count, 1) + self.assertEqual(observation.index_predecessor_count, 1) + self.assertEqual(observation.worktree_predecessor_count, 1) + self.assertEqual(self._git(root, "ls-files", "--stage", "-z"), index_before) + status_after = subprocess.run( + ("git", "-C", str(root), "status", "--porcelain=v1", "-z"), + check=True, stdout=subprocess.PIPE, + ).stdout + self.assertEqual(status_after, status_before) + self.assertEqual((root / "other.txt").read_bytes(), b"unrelated unstaged\n") + self.assertEqual((root / "untracked.txt").read_bytes(), b"unrelated untracked\n") + + def test_publication_checkout_reports_other_branch_and_detached_head(self) -> None: + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) + self._initialize(root) + (root / "value.txt").write_bytes(b"predecessor\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + repository = GitRepository(root) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + self.assertEqual(repository.publish_candidate(candidate, expected), "updated") + self._git(root, "switch", "-qc", "other") + other = repository.observe_publication_checkout(expected, candidate.revision) + self.assertEqual(other.status, "not-target-checkout") + self.assertEqual(other.symbolic_branch, "refs/heads/other") + self._git(root, "checkout", "--detach", expected.oid) + detached = repository.observe_publication_checkout(expected, candidate.revision) + self.assertEqual(detached.status, "not-target-checkout") + self.assertIsNone(detached.symbolic_branch) + + def test_publication_checkout_reports_unmerged_index_as_conflicted(self) -> None: + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) + self._initialize(root) + (root / "value.txt").write_bytes(b"base\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + repository = GitRepository(root) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + self._git(root, "switch", "-qc", "other") + (root / "value.txt").write_bytes(b"other branch\n") + self._commit(root, "other edit") + self._git(root, "switch", "main") + (root / "value.txt").write_bytes(b"main branch\n") + self._commit(root, "main edit") + merged = subprocess.run( + ("git", "-C", str(root), "merge", "other"), + stdout=subprocess.PIPE, stderr=subprocess.PIPE, + ) + self.assertNotEqual(merged.returncode, 0) + observation = repository.observe_publication_checkout(expected, candidate.revision) + self.assertEqual(observation.status, "conflicted") + + def test_publication_checkout_does_not_follow_ancestor_swapped_to_symlink(self) -> None: + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) / "repository" + outside = Path(temporary) / "outside" + (root / "nested").mkdir(parents=True) + outside.mkdir() + self._initialize(root) + (root / "nested" / "value.txt").write_bytes(b"predecessor\n") + (outside / "value.txt").write_bytes(b"external bait\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + repository = GitRepository(root) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("nested/value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + original_open = os.open + opened_leaf: list[bytes | str] = [] + swapped = False + + def swap_after_parent_open(path, flags, *args, **kwargs): + nonlocal swapped + descriptor = original_open(path, flags, *args, **kwargs) + if kwargs.get("dir_fd") is not None and os.fsdecode(path) == "nested" and not swapped: + swapped = True + (root / "nested").rename(root / "nested-original") + (root / "nested").symlink_to(outside, target_is_directory=True) + if kwargs.get("dir_fd") is not None and os.fsdecode(path) == "value.txt": + opened_leaf.append(path) + return descriptor + + try: + with ( + mock.patch.object(repository_module, "_supports_safe_dirfd_observation", return_value=True), + mock.patch.object(repository_module.os, "open", side_effect=swap_after_parent_open), + ): + with self.assertRaises(GitRepositoryError) as observed: + repository.observe_publication_checkout(expected, candidate.revision) + self.assertEqual(observed.exception.failure.code, "REPOSITORY_GIT.OBSERVATION_STALE") + self.assertTrue(swapped) + self.assertEqual(opened_leaf, []) + self.assertEqual((outside / "value.txt").read_bytes(), b"external bait\n") + finally: + if (root / "nested").is_symlink(): + (root / "nested").unlink() + if (root / "nested-original").exists(): + (root / "nested-original").rename(root / "nested") + + def test_publication_checkout_rechecks_ancestors_after_final_git_reads(self) -> None: + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) / "repository" + outside = Path(temporary) / "outside" + (root / "nested").mkdir(parents=True) + outside.mkdir() + self._initialize(root) + (root / "nested" / "value.txt").write_bytes(b"predecessor\n") + (outside / "value.txt").write_bytes(b"predecessor\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + repository = GitRepository(root) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("nested/value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + original_index = repository_module._publication_index_observation + index_reads = 0 + + def swap_after_final_index_read(*args, **kwargs): + nonlocal index_reads + result = original_index(*args, **kwargs) + index_reads += 1 + if index_reads == 2: + (root / "nested").rename(root / "nested-original") + (root / "nested").symlink_to(outside, target_is_directory=True) + return result + + try: + with mock.patch.object( + repository_module, "_publication_index_observation", + side_effect=swap_after_final_index_read, + ): + with self.assertRaises(GitRepositoryError) as observed: + repository.observe_publication_checkout(expected, candidate.revision) + self.assertEqual(index_reads, 2) + self.assertEqual(observed.exception.failure.code, "REPOSITORY_GIT.OBSERVATION_STALE") + self.assertEqual((outside / "value.txt").read_bytes(), b"predecessor\n") + finally: + if (root / "nested").is_symlink(): + (root / "nested").unlink() + if (root / "nested-original").exists(): + (root / "nested-original").rename(root / "nested") + + def test_publication_checkout_rechecks_git_roots_after_persistent_substitution(self) -> None: + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) / "repository" + replacement = Path(temporary) / "replacement" + alias = Path(temporary) / "checkout" + root.mkdir() + self._initialize(root) + (root / "value.txt").write_bytes(b"predecessor\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + alias.symlink_to(root, target_is_directory=True) + repository = GitRepository(alias) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + shutil.copytree(root, replacement) + original_observer = repository_module._worktree_entry_matches + substituted = False + + def substitute_after_path_check(*args, **kwargs): + nonlocal substituted + result = original_observer(*args, **kwargs) + if not substituted: + substituted = True + alias.unlink() + alias.symlink_to(replacement, target_is_directory=True) + return result + + with ( + mock.patch.object(repository_module, "_worktree_entry_matches", side_effect=substitute_after_path_check), + mock.patch.object(repository_module, "git_command", wraps=repository_module.git_command) as commands, + ): + with self.assertRaises(GitRepositoryError) as observed: + repository.observe_publication_checkout(expected, candidate.revision) + self.assertTrue(substituted) + self.assertEqual(observed.exception.failure.code, "REPOSITORY_GIT.OBSERVATION_STALE") + self.assertEqual(self._git(root, "rev-parse", "HEAD"), self._git(replacement, "rev-parse", "HEAD")) + self.assertEqual(self._git(root, "ls-files", "--stage", "-z"), self._git(replacement, "ls-files", "--stage", "-z")) + self.assertTrue(all(call.kwargs.get("local_only") is True for call in commands.call_args_list)) + for selector in ("--show-toplevel", "--git-dir", "--git-common-dir"): + self.assertEqual(sum(selector in call.args[1] for call in commands.call_args_list), 2) + + def test_publication_checkout_rejects_administrative_root_replaced_at_same_path(self) -> None: + for selected_directory in ("private", "common"): + with self.subTest(directory=selected_directory), tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) / "repository" + linked = Path(temporary) / "linked" + replacement = Path(temporary) / "replacement" + original = Path(temporary) / "original" + root.mkdir() + self._initialize(root) + (root / "value.txt").write_bytes(b"predecessor\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + self._git(root, "worktree", "add", "-b", "observed", str(linked), "HEAD") + repository = GitRepository(linked) + expected = repository.branch_revision("main") + initial_bindings = repository._publication_checkout_bindings() + administrative_root = initial_bindings[1 if selected_directory == "private" else 2] + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + head_before = self._git(linked, "rev-parse", "HEAD") + ref_before = self._git(linked, "rev-parse", "refs/heads/main") + index_before = self._git(linked, "ls-files", "--stage", "-z") + identity_before = administrative_root.stat() + shutil.copytree(administrative_root, replacement) + original_observer = repository_module._worktree_entry_matches + substituted = False + + def substitute_after_path_check(*args, **kwargs): + nonlocal substituted + result = original_observer(*args, **kwargs) + if not substituted: + substituted = True + administrative_root.rename(original) + replacement.rename(administrative_root) + return result + + try: + with mock.patch.object( + repository_module, "_worktree_entry_matches", side_effect=substitute_after_path_check, + ): + with self.assertRaises(GitRepositoryError) as observed: + repository.observe_publication_checkout(expected, candidate.revision) + self.assertTrue(substituted) + self.assertEqual(observed.exception.failure.code, "REPOSITORY_GIT.OBSERVATION_STALE") + self.assertEqual(repository._publication_checkout_bindings(), initial_bindings) + self.assertFalse(repository_module._same_file_identity(identity_before, administrative_root.stat())) + self.assertEqual(self._git(linked, "rev-parse", "HEAD"), head_before) + self.assertEqual(self._git(linked, "rev-parse", "refs/heads/main"), ref_before) + self.assertEqual(self._git(linked, "ls-files", "--stage", "-z"), index_before) + finally: + if original.exists(): + shutil.rmtree(administrative_root) + original.rename(administrative_root) + + def test_publication_checkout_owns_initial_descriptor_allocation_failures(self) -> None: + for failed_allocation in ("duplicate", "first-root-open", "second-root-open"): + with self.subTest(allocation=failed_allocation), tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) + self._initialize(root) + (root / "value.txt").write_bytes(b"predecessor\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + repository = GitRepository(root) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + original_open = os.open + original_close = os.close + original_dup = os.dup + opened: set[int] = set() + root_opens = 0 + allocation_failed = False + + def open_directory(path, flags, *args, **kwargs): + nonlocal root_opens, allocation_failed + if flags & os.O_DIRECTORY and kwargs.get("dir_fd") is None: + root_opens += 1 + if ( + (failed_allocation == "first-root-open" and root_opens == 1) + or (failed_allocation == "second-root-open" and root_opens == 2) + ): + allocation_failed = True + raise OSError(errno.EMFILE, "injected descriptor exhaustion") + descriptor = original_open(path, flags, *args, **kwargs) + if flags & os.O_DIRECTORY: + opened.add(descriptor) + return descriptor + + def duplicate_directory(descriptor): + nonlocal allocation_failed + if failed_allocation == "duplicate": + allocation_failed = True + raise OSError(errno.EMFILE, "injected descriptor exhaustion") + duplicate = original_dup(descriptor) + opened.add(duplicate) + return duplicate + + def close_directory(descriptor): + original_close(descriptor) + opened.discard(descriptor) + + with ( + mock.patch.object(repository_module, "_supports_safe_dirfd_observation", return_value=True), + mock.patch.object(repository_module.os, "open", side_effect=open_directory), + mock.patch.object(repository_module.os, "dup", side_effect=duplicate_directory), + mock.patch.object(repository_module.os, "close", side_effect=close_directory), + ): + with self.assertRaises(GitRepositoryError) as observed: + repository.observe_publication_checkout(expected, candidate.revision) + self.assertTrue(allocation_failed) + self.assertEqual(observed.exception.failure.kind, "unavailable") + self.assertEqual(observed.exception.failure.code, "REPOSITORY_GIT.WORKTREE_UNAVAILABLE") + self.assertIsInstance(observed.exception.__cause__, OSError) + self.assertEqual(observed.exception.__cause__.errno, errno.EMFILE) + self.assertEqual(opened, set()) + + def test_publication_checkout_closes_descriptors_on_cancellation(self) -> None: + original_open = os.open + original_dup = os.dup + original_fstat = os.fstat + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) + (root / "nested").mkdir() + opened: list[int] = [] + + def cancel_during_component_open(path, flags, *args, **kwargs): + if kwargs.get("dir_fd") is not None: + raise KeyboardInterrupt + descriptor = original_open(path, flags, *args, **kwargs) + opened.append(descriptor) + return descriptor + + with ( + mock.patch.object(repository_module, "_supports_safe_dirfd_observation", return_value=True), + mock.patch.object(repository_module.os, "open", side_effect=cancel_during_component_open), + ): + with self.assertRaises(KeyboardInterrupt): + repository_module._open_absolute_directory(root / "nested") + self.assertEqual(len(opened), 1) + for descriptor in opened: + with self.assertRaises(OSError): + original_fstat(descriptor) + + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) + self._initialize(root) + (root / "nested").mkdir() + (root / "nested/value.txt").write_bytes(b"predecessor\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + repository = GitRepository(root) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("nested/value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + opened_directories: list[int] = [] + + def track_directory_open(path, flags, *args, **kwargs): + descriptor = original_open(path, flags, *args, **kwargs) + if flags & os.O_DIRECTORY: + opened_directories.append(descriptor) + return descriptor + + def track_directory_duplicate(descriptor): + duplicate = original_dup(descriptor) + opened_directories.append(duplicate) + return duplicate + + def cancel_on_directory_inspection(_descriptor): + raise KeyboardInterrupt + + with ( + mock.patch.object(repository_module, "_supports_safe_dirfd_observation", return_value=True), + mock.patch.object(repository_module.os, "open", side_effect=track_directory_open), + mock.patch.object(repository_module.os, "dup", side_effect=track_directory_duplicate), + mock.patch.object(repository_module.os, "fstat", side_effect=cancel_on_directory_inspection), + ): + with self.assertRaises(KeyboardInterrupt): + repository.observe_publication_checkout(expected, candidate.revision) + self.assertGreaterEqual(len(opened_directories), 4) + for descriptor in opened_directories: + with self.assertRaises(OSError): + original_fstat(descriptor) + + def test_publication_checkout_rechecks_target_ref_after_path_observation(self) -> None: + with tempfile.TemporaryDirectory(dir="/tmp") as temporary: + root = Path(temporary) + self._initialize(root) + (root / "value.txt").write_bytes(b"predecessor\n") + self._commit(root, "initial") + self._git(root, "branch", "-M", "main") + repository = GitRepository(root) + expected = repository.branch_revision("main") + with repository.materialize_candidate( + expected, + (CandidateFile(RepositoryPath.parse("value.txt"), b"candidate\n", False),), + commit=_COMMIT, + ) as candidate: + self.assertEqual(repository.publish_candidate(candidate, expected), "updated") + self._git(root, "switch", "-qc", "other") + original_observer = repository_module._worktree_entry_matches + changed = False + + def advance_observed_paths(*args, **kwargs): + nonlocal changed + result = original_observer(*args, **kwargs) + if not changed: + changed = True + self._git(root, "update-ref", "refs/heads/main", expected.oid) + return result + + with mock.patch.object( + repository_module, "_worktree_entry_matches", side_effect=advance_observed_paths + ): + with self.assertRaises(GitRepositoryError) as observed: + repository.observe_publication_checkout(expected, candidate.revision) + self.assertTrue(changed) + self.assertEqual(observed.exception.failure.code, "REPOSITORY_GIT.OBSERVATION_STALE") + + def test_candidate_is_isolated_and_published_by_expected_target(self) -> None: with tempfile.TemporaryDirectory(dir="/tmp") as temporary: root = Path(temporary) diff --git a/tools/standards_analysis/standards_analysis/__init__.py b/tools/standards_analysis/standards_analysis/__init__.py index 32a970c7..b55531dc 100644 --- a/tools/standards_analysis/standards_analysis/__init__.py +++ b/tools/standards_analysis/standards_analysis/__init__.py @@ -108,12 +108,16 @@ construct_authorization_record, ) -from .coverage_publication import render_engine_coverage_receipt +from .coverage_publication import ( + render_engine_coverage_receipt, + validate_engine_coverage_receipt_evidence, +) from .router_guidance import RouterGuidance, RoutingSelectionRow, parse_router_guidance __all__ = ( "render_engine_coverage_receipt", + "validate_engine_coverage_receipt_evidence", "RouterGuidance", "RoutingSelectionRow", "parse_router_guidance", diff --git a/tools/standards_analysis/standards_analysis/coverage_publication.py b/tools/standards_analysis/standards_analysis/coverage_publication.py index 3965f117..ef08ea76 100644 --- a/tools/standards_analysis/standards_analysis/coverage_publication.py +++ b/tools/standards_analysis/standards_analysis/coverage_publication.py @@ -26,6 +26,7 @@ construct_authorization_record, resolve_authorization, ) +from .errors import AnalysisError from .keys import analysis_identity @@ -121,6 +122,64 @@ def _resolved_value(evidence: ResolvedEvidence) -> dict[str, object]: } +def _with_evidence_context( + error: AnalysisError, + *, + phase: str, + source_kind: str, + material_identity: str | None, + next_action: str, +) -> AnalysisError: + return AnalysisError(replace( + error.failure, + validation_phase=phase, + source_kind=source_kind, + material_identity=material_identity, + next_action=next_action, + )) + + +def validate_engine_coverage_receipt_evidence( + source: ContentSource, + definitions: CoverageDefinitionIndex, + subject: str, + claim: Mapping[str, object], + review_authorization: Mapping[str, object], + analysis_id: str, + *, + phase: str, + source_kind: str, + material_identity: str | None, + next_action: str, +) -> tuple[ResolvedEvidence, ...]: + """Validate destination evidence without issuing publication authority.""" + try: + _bound_claim(subject, claim, definitions) + _text(analysis_id, path="Engine receipt", field="analysis_id") + resolved = tuple( + ResolvedEvidence(reference, source.read_bytes(reference.id)) + for reference in _request(claim).evidence + ) + authorization_reference = review_authorization.get("reference") + if ( + type(authorization_reference) is not dict + or claim["authorization_id"] != authorization_reference.get("id") + ): + raise _error( + "COVERAGE.PUBLICATION_AUTHORITY_CHANGED", + "Publication requires the exact Engine authority that authorized the review.", + ) + return resolved + except AnalysisError as error: + raise _with_evidence_context( + error, + phase=phase, + source_kind=source_kind, + material_identity=material_identity, + next_action=next_action, + ) from error + + def render_engine_coverage_receipt( source: ContentSource, definitions: CoverageDefinitionIndex, @@ -129,14 +188,36 @@ def render_engine_coverage_receipt( review_authorization: Mapping[str, object], analysis_id: str, context: AnalysisExecutionContext, + *, + phase: str = "candidate-evidence", + source_kind: str = "repository-content", + material_identity: str | None = None, ) -> bytes: """Reauthorize an exact reviewed claim and retain its current authority proof.""" - _bound_claim(subject, claim, definitions) + validate_engine_coverage_receipt_evidence( + source, + definitions, + subject, + claim, + review_authorization, + analysis_id, + phase=phase, + source_kind=source_kind, + material_identity=material_identity, + next_action="refresh-review-evidence", + ) request = _request(claim) # The destination bytes, not the authorizer's working tree, must match too. - for reference in request.evidence: - ResolvedEvidence(reference, source.read_bytes(reference.id)) - resolved = resolve_authorization(context, request) + try: + resolved = resolve_authorization(context, request) + except AnalysisError as error: + raise _with_evidence_context( + error, + phase="decision-authorization", + source_kind="authorization-evidence", + material_identity=None, + next_action="refresh-authorization-evidence", + ) from error authorization = resolved.record.as_contract() if ( authorization != review_authorization @@ -146,9 +227,18 @@ def render_engine_coverage_receipt( "COVERAGE.PUBLICATION_AUTHORITY_CHANGED", "Publication requires the exact Engine authority that authorized the review.", ) - publication = resolve_authorization( - context, _publication_request(subject, claim, analysis_id, authorization) - ) + try: + publication = resolve_authorization( + context, _publication_request(subject, claim, analysis_id, authorization) + ) + except AnalysisError as error: + raise _with_evidence_context( + error, + phase="candidate-evidence", + source_kind="authorization-evidence", + material_identity=None, + next_action="refresh-publication-authorization", + ) from error value = { "schema_version": 1, "subject": subject, diff --git a/tools/standards_analysis/standards_analysis/errors.py b/tools/standards_analysis/standards_analysis/errors.py index 511acb93..3faa7600 100644 --- a/tools/standards_analysis/standards_analysis/errors.py +++ b/tools/standards_analysis/standards_analysis/errors.py @@ -11,6 +11,15 @@ class AnalysisFailure: path: str | None = None field: str | None = None observed: str | None = None + validation_phase: str | None = None + evidence_reference: str | None = None + provider_contract: str | None = None + provider_contract_version: str | None = None + source_kind: str | None = None + material_identity: str | None = None + expected_digest: str | None = None + observed_digest: str | None = None + next_action: str | None = None class AnalysisError(Exception): diff --git a/tools/standards_analysis/standards_analysis/trust.py b/tools/standards_analysis/standards_analysis/trust.py index e1b39fd8..8fea470e 100644 --- a/tools/standards_analysis/standards_analysis/trust.py +++ b/tools/standards_analysis/standards_analysis/trust.py @@ -82,10 +82,16 @@ def __post_init__(self) -> None: ) digest = "sha256:" + hashlib.sha256(self.content).hexdigest() if digest != self.reference.digest: - raise _error( + raise AnalysisError(AnalysisFailure( "ANALYSIS.EVIDENCE_DIGEST_MISMATCH", + "invalid", "Resolved evidence bytes do not match the declared digest.", - ) + evidence_reference=self.reference.id, + provider_contract=self.reference.provider_contract, + provider_contract_version=self.reference.provider_contract_version, + expected_digest=self.reference.digest, + observed_digest=digest, + )) @dataclass(frozen=True, slots=True) diff --git a/tools/standards_engine/PURPOSE-SEPARATION.md b/tools/standards_engine/PURPOSE-SEPARATION.md index a13c2cad..753ad50b 100644 --- a/tools/standards_engine/PURPOSE-SEPARATION.md +++ b/tools/standards_engine/PURPOSE-SEPARATION.md @@ -433,10 +433,13 @@ those schemas. Store selection must remain unchanged if the installed host used a nondefault store. Handoff data is the exact readiness/context, not a fabricated handle assembled from a truncated identifier. -Authoring failure details carry the Git operation, exit code and recognized -fixed stderr phrase when available. Raw stderr can contain sensitive paths or -hook output and stays in the private Git exception, not the MCP response. Earlier -uncaptured stderr cannot be recovered retrospectively. Obtain a new bounded +Authoring analysis failures retain legacy `path`, `field` and `observed` context +only when each value is bounded and matches its safe character and path rules. +Absolute and traversal paths and multiline observations are omitted. Application +purpose omits these details. Git failure details carry the operation, exit code +and recognized fixed stderr phrase when available. Raw stderr can contain sensitive +paths or hook output and stays in the private Git exception, not the MCP response. +Earlier uncaptured stderr cannot be recovered retrospectively. Obtain a new bounded observation from the supported operation on the correct host. Ordinary application interfaces still cannot call either recovery operation or read its diagnostics. @@ -969,3 +972,27 @@ material hashes and persisted state are not migrated. Historical saved focused c must use matching source/tooling; new tasks may reuse their still-valid snapshot with the new syntax. Output delivery, discovery bounds and all other operations are unchanged. The existing client/model qualification is separate from static agreement. + + +## Publication evidence (interface 46) + +Native apply and recovery results retain the durable application handle, exact +candidate commit and tree, target ref, expected predecessor, and whether the +application outcome is recorded, merely admitted, or unavailable. They also +include a fresh observation of the target ref and selected checkout. Recovery +re-reads both observations, including when the durable applied outcome already +exists after a process restart. `workflow_status` supplies the same observations +for an admitted application without duplicating them when its outcome already +contains them. + +Checkout observation is read-only. It reports whether the selected checkout is +the target branch, agrees with the predecessor or candidate on changed +publication paths, needs reconciliation, or has conflicts. Path counts are +reported separately for the index and worktree; unrelated changes do not count. +An unavailable observation carries null observation fields rather than guessed +values. Its failure never changes or hides a successful durable application. + +This interface does not stage or repair a checkout, retry publication, or infer +that an unrelated checkout was updated. Request contract 6, result state and +persisted application/workflow identities remain unchanged. Generated contracts +and the client catalog must be refreshed together with interface 46. diff --git a/tools/standards_engine/README.md b/tools/standards_engine/README.md index 96db526f..bb0473ef 100644 --- a/tools/standards_engine/README.md +++ b/tools/standards_engine/README.md @@ -1,6 +1,6 @@ # Standards Engine -The current interface is **45**. Input contracts are native-only; `--schema-mode` +The current interface is **46**. 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. @@ -12,6 +12,13 @@ catalog after installing the coordinated source and generated contracts; preserv existing stores and exact workflow handles. See the [boundary repair record](../../docs/plans/boundary-repairs/plan.md). +Interface 46 returns durable publication identity and a fresh, read-only checkout +observation from native apply/recover results. `workflow_status` also observes +both when an application has been admitted. Checkout observation failures are +reported as unavailable and do not change an already successful publication +result. Request contract 6 and persisted workflow identities are unchanged. +See [the publication evidence contract](PURPOSE-SEPARATION.md#publication-evidence-interface-46). + The versioned sections below retain implementation history. ## Purpose separation (interface 31) diff --git a/tools/standards_engine/contracts/README.md b/tools/standards_engine/contracts/README.md index 4348b79d..4bb13f27 100644 --- a/tools/standards_engine/contracts/README.md +++ b/tools/standards_engine/contracts/README.md @@ -1,5 +1,11 @@ # Standards Engine Contracts +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 +changing an already successful mutation. Request contract 6 and persisted state +versions remain unchanged. See [the interface-46 contract](../PURPOSE-SEPARATION.md#publication-evidence-interface-46). + Interface 40 adds `describe_input` for bounded, catalog-bound input-contract discovery. Both purposes use the same observation algebra; only actually published operations and their input closure are visible. Mutation/state/handle contracts diff --git a/tools/standards_engine/contracts/a1-contract.schema.json b/tools/standards_engine/contracts/a1-contract.schema.json index 1f9cea61..ac20e9a8 100644 --- a/tools/standards_engine/contracts/a1-contract.schema.json +++ b/tools/standards_engine/contracts/a1-contract.schema.json @@ -305,6 +305,12 @@ "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}$" @@ -3342,7 +3348,9 @@ "required": [ "kind", "application", - "status" + "status", + "publication", + "checkout" ], "properties": { "kind": { @@ -3353,6 +3361,12 @@ }, "status": { "const": "applied" + }, + "publication": { + "$ref": "#/$defs/ApplicationPublicationReceipt" + }, + "checkout": { + "$ref": "#/$defs/PublicationCheckoutObservation" } }, "additionalProperties": false @@ -3386,7 +3400,9 @@ "required": [ "kind", "application", - "status" + "status", + "publication", + "checkout" ], "properties": { "kind": { @@ -3397,6 +3413,12 @@ }, "status": { "const": "applied" + }, + "publication": { + "$ref": "#/$defs/ApplicationPublicationReceipt" + }, + "checkout": { + "$ref": "#/$defs/PublicationCheckoutObservation" } }, "additionalProperties": false @@ -3409,7 +3431,9 @@ "status", "code", "outcome", - "message" + "message", + "publication", + "checkout" ], "properties": { "kind": { @@ -3425,6 +3449,7 @@ "enum": [ "APPLICATION.PUBLICATION_UNAVAILABLE", "APPLICATION.OBSERVATION_UNAVAILABLE", + "APPLICATION.OUTCOME_OBSERVATION_UNAVAILABLE", "APPLICATION.OUTCOME_PERSISTENCE_UNAVAILABLE", "APPLICATION.RECOVERY_TARGET_UNCERTAIN", "APPLICATION.RECOVERY_TARGET_DIVERGED", @@ -3437,6 +3462,12 @@ "message": { "$ref": "#/$defs/NonEmptyString" }, + "publication": { + "$ref": "#/$defs/ApplicationPublicationReceipt" + }, + "checkout": { + "$ref": "#/$defs/PublicationCheckoutObservation" + }, "details": { "type": "object", "additionalProperties": { @@ -3446,6 +3477,91 @@ }, "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": [ @@ -6569,6 +6685,12 @@ "revision": { "$ref": "#/$defs/ProposalRevisionHandle" }, + "publication": { + "$ref": "#/$defs/ApplicationPublicationReceipt" + }, + "checkout": { + "$ref": "#/$defs/PublicationCheckoutObservation" + }, "status": { "enum": [ "draft", diff --git a/tools/standards_engine/contracts/a1-interface.toml b/tools/standards_engine/contracts/a1-interface.toml index a2ae8673..ddc3c3f6 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 = 45 +interface_schema_version = 46 request_contract_version = 6 -result_projection_version = 7 +result_projection_version = 8 [[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 1ec6eaa5..501ebe8a 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": 45, + "interface_schema_version": 46, "examples": [ { "name": "create-snapshot", @@ -1274,7 +1274,7 @@ "value": { "kind": "input-contract-result", "purpose": "application", - "interface_version": 45, + "interface_version": 46, "catalog_digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "operation": "runtime_info", "root": "RuntimeInfoCall", @@ -1420,7 +1420,7 @@ "value": { "kind": "output-contract-result", "purpose": "authoring", - "interface_version": 45, + "interface_version": 46, "catalog_digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "operation": "review", "dialect": "https://json-schema.org/draft/2020-12/schema", @@ -1473,6 +1473,143 @@ "limit": 8 } } + }, + { + "name": "apply-proposal-publication-receipt", + "definition": "ApplyProposalResult", + "value": { + "kind": "apply-proposal-result", + "application": { + "kind": "application-handle", + "id": "application:sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "schema_version": 1 + }, + "status": "applied", + "publication": { + "kind": "application-publication-receipt", + "application": { + "kind": "application-handle", + "id": "application:sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "schema_version": 1 + }, + "candidate_commit": "1111111111111111111111111111111111111111", + "candidate_tree": "2222222222222222222222222222222222222222", + "target_ref": "refs/heads/main", + "expected_predecessor": "3333333333333333333333333333333333333333", + "durable_state": "applied", + "target_observation": { + "kind": "publication-target-observation", + "status": "candidate", + "revision": "1111111111111111111111111111111111111111" + } + }, + "checkout": { + "kind": "publication-checkout-observation", + "status": "needs-reconciliation", + "worktree_id": "sha256:dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd", + "symbolic_branch": "refs/heads/main", + "head": "1111111111111111111111111111111111111111", + "index_observation": "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + "publication_path_count": 2, + "index_paths": { + "predecessor": 2, + "candidate": 0, + "conflicted": 0 + }, + "worktree_paths": { + "predecessor": 2, + "candidate": 0, + "conflicted": 0 + } + } + } + }, + { + "name": "recover-application-publication-observation", + "definition": "RecoverApplicationResult", + "value": { + "kind": "recover-application-result", + "application": { + "kind": "application-handle", + "id": "application:sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "schema_version": 1 + }, + "status": "applied", + "publication": { + "kind": "application-publication-receipt", + "application": { + "kind": "application-handle", + "id": "application:sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "schema_version": 1 + }, + "candidate_commit": "1111111111111111111111111111111111111111", + "candidate_tree": "2222222222222222222222222222222222222222", + "target_ref": "refs/heads/main", + "expected_predecessor": "3333333333333333333333333333333333333333", + "durable_state": "applied", + "target_observation": { + "kind": "publication-target-observation", + "status": "candidate", + "revision": "1111111111111111111111111111111111111111" + } + }, + "checkout": { + "kind": "publication-checkout-observation", + "status": "current", + "worktree_id": "sha256:dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd", + "symbolic_branch": "refs/heads/main", + "head": "1111111111111111111111111111111111111111", + "index_observation": "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + "publication_path_count": 2, + "index_paths": {"predecessor": 0, "candidate": 2, "conflicted": 0}, + "worktree_paths": {"predecessor": 0, "candidate": 2, "conflicted": 0} + } + } + }, + { + "name": "application-recovery-unavailable-observations", + "definition": "ApplicationRecoveryRequiredResult", + "value": { + "kind": "application-recovery-required-result", + "application": { + "kind": "application-handle", + "id": "application:sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "schema_version": 1 + }, + "status": "recovery-required", + "code": "APPLICATION.PUBLICATION_UNAVAILABLE", + "outcome": "unavailable", + "message": "The publication target could not be observed.", + "publication": { + "kind": "application-publication-receipt", + "application": { + "kind": "application-handle", + "id": "application:sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "schema_version": 1 + }, + "candidate_commit": "1111111111111111111111111111111111111111", + "candidate_tree": null, + "target_ref": "refs/heads/main", + "expected_predecessor": "3333333333333333333333333333333333333333", + "durable_state": "admitted", + "target_observation": { + "kind": "publication-target-observation", + "status": "unavailable", + "revision": null + } + }, + "checkout": { + "kind": "publication-checkout-observation", + "status": "unavailable", + "worktree_id": null, + "symbolic_branch": null, + "head": null, + "index_observation": null, + "publication_path_count": null, + "index_paths": {"predecessor": null, "candidate": null, "conflicted": null}, + "worktree_paths": {"predecessor": null, "candidate": null, "conflicted": null} + } + } } ] } diff --git a/tools/standards_engine/contracts/generated/agent-tools.json b/tools/standards_engine/contracts/generated/agent-tools.json index e63f72ab..9c181be4 100644 --- a/tools/standards_engine/contracts/generated/agent-tools.json +++ b/tools/standards_engine/contracts/generated/agent-tools.json @@ -1315,6 +1315,58 @@ ], "type": "object" }, + "ApplicationPublicationReceipt": { + "additionalProperties": false, + "description": "Durable application identity and exact candidate facts, separate from the fresh target observation.", + "properties": { + "application": { + "$ref": "#/$defs/ApplicationHandle" + }, + "candidate_commit": { + "$ref": "#/$defs/GitObjectId" + }, + "candidate_tree": { + "oneOf": [ + { + "$ref": "#/$defs/GitObjectId" + }, + { + "type": "null" + } + ] + }, + "durable_state": { + "enum": [ + "applied", + "admitted", + "unknown" + ] + }, + "expected_predecessor": { + "$ref": "#/$defs/GitObjectId" + }, + "kind": { + "const": "application-publication-receipt" + }, + "target_observation": { + "$ref": "#/$defs/PublicationTargetObservation" + }, + "target_ref": { + "const": "refs/heads/main" + } + }, + "required": [ + "kind", + "application", + "candidate_commit", + "candidate_tree", + "target_ref", + "expected_predecessor", + "durable_state", + "target_observation" + ], + "type": "object" + }, "ApplicationQueryCall": { "additionalProperties": false, "properties": { @@ -1565,10 +1617,14 @@ "application": { "$ref": "#/$defs/ApplicationHandle" }, + "checkout": { + "$ref": "#/$defs/PublicationCheckoutObservation" + }, "code": { "enum": [ "APPLICATION.PUBLICATION_UNAVAILABLE", "APPLICATION.OBSERVATION_UNAVAILABLE", + "APPLICATION.OUTCOME_OBSERVATION_UNAVAILABLE", "APPLICATION.OUTCOME_PERSISTENCE_UNAVAILABLE", "APPLICATION.RECOVERY_TARGET_UNCERTAIN", "APPLICATION.RECOVERY_TARGET_DIVERGED", @@ -1590,6 +1646,9 @@ "outcome": { "const": "unavailable" }, + "publication": { + "$ref": "#/$defs/ApplicationPublicationReceipt" + }, "status": { "const": "recovery-required" } @@ -1600,7 +1659,9 @@ "status", "code", "outcome", - "message" + "message", + "publication", + "checkout" ], "type": "object" }, @@ -1889,9 +1950,15 @@ "application": { "$ref": "#/$defs/ApplicationHandle" }, + "checkout": { + "$ref": "#/$defs/PublicationCheckoutObservation" + }, "kind": { "const": "apply-proposal-result" }, + "publication": { + "$ref": "#/$defs/ApplicationPublicationReceipt" + }, "status": { "const": "applied" } @@ -1899,7 +1966,9 @@ "required": [ "kind", "application", - "status" + "status", + "publication", + "checkout" ], "type": "object" }, @@ -4512,6 +4581,18 @@ ], "type": "object" }, + "GitObjectId": { + "oneOf": [ + { + "pattern": "^[0-9a-f]{40}$", + "type": "string" + }, + { + "pattern": "^[0-9a-f]{64}$", + "type": "string" + } + ] + }, "ImpactDispositionSubmission": { "additionalProperties": false, "properties": { @@ -6389,6 +6470,155 @@ ], "type": "object" }, + "PublicationCheckoutObservation": { + "additionalProperties": false, + "description": "Fresh read-only observation of one selected checkout. Unavailable observations use null for every fact that could not be established.", + "properties": { + "head": { + "oneOf": [ + { + "$ref": "#/$defs/GitObjectId" + }, + { + "type": "null" + } + ] + }, + "index_observation": { + "oneOf": [ + { + "$ref": "#/$defs/Digest" + }, + { + "type": "null" + } + ] + }, + "index_paths": { + "$ref": "#/$defs/PublicationPathCounts" + }, + "kind": { + "const": "publication-checkout-observation" + }, + "publication_path_count": { + "minimum": 0, + "type": [ + "integer", + "null" + ] + }, + "status": { + "enum": [ + "not-observed", + "unavailable", + "not-target-checkout", + "current", + "needs-reconciliation", + "conflicted" + ] + }, + "symbolic_branch": { + "oneOf": [ + { + "$ref": "#/$defs/NonEmptyString" + }, + { + "type": "null" + } + ] + }, + "worktree_id": { + "oneOf": [ + { + "$ref": "#/$defs/Digest" + }, + { + "type": "null" + } + ] + }, + "worktree_paths": { + "$ref": "#/$defs/PublicationPathCounts" + } + }, + "required": [ + "kind", + "status", + "worktree_id", + "symbolic_branch", + "head", + "index_observation", + "publication_path_count", + "index_paths", + "worktree_paths" + ], + "type": "object" + }, + "PublicationPathCounts": { + "additionalProperties": false, + "properties": { + "candidate": { + "minimum": 0, + "type": [ + "integer", + "null" + ] + }, + "conflicted": { + "minimum": 0, + "type": [ + "integer", + "null" + ] + }, + "predecessor": { + "minimum": 0, + "type": [ + "integer", + "null" + ] + } + }, + "required": [ + "predecessor", + "candidate", + "conflicted" + ], + "type": "object" + }, + "PublicationTargetObservation": { + "additionalProperties": false, + "description": "Fresh bounded observation of the configured target ref; an unavailable revision is null.", + "properties": { + "kind": { + "const": "publication-target-observation" + }, + "revision": { + "oneOf": [ + { + "$ref": "#/$defs/GitObjectId" + }, + { + "type": "null" + } + ] + }, + "status": { + "enum": [ + "candidate", + "expected", + "diverged", + "unavailable" + ] + } + }, + "required": [ + "kind", + "status", + "revision" + ], + "type": "object" + }, "PutDecisionProvenanceEdit": { "additionalProperties": false, "properties": { @@ -7019,9 +7249,15 @@ "application": { "$ref": "#/$defs/ApplicationHandle" }, + "checkout": { + "$ref": "#/$defs/PublicationCheckoutObservation" + }, "kind": { "const": "recover-application-result" }, + "publication": { + "$ref": "#/$defs/ApplicationPublicationReceipt" + }, "status": { "const": "applied" } @@ -7029,7 +7265,9 @@ "required": [ "kind", "application", - "status" + "status", + "publication", + "checkout" ], "type": "object" }, @@ -9506,6 +9744,9 @@ "additionalProperties": false, "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.", "properties": { + "checkout": { + "$ref": "#/$defs/PublicationCheckoutObservation" + }, "context": { "$ref": "#/$defs/WorkflowContext" }, @@ -9524,6 +9765,9 @@ "proposal": { "$ref": "#/$defs/ProposalHandle" }, + "publication": { + "$ref": "#/$defs/ApplicationPublicationReceipt" + }, "revision": { "$ref": "#/$defs/ProposalRevisionHandle" }, @@ -9694,7 +9938,7 @@ "type": "object" } }, - "interface_schema_version": 45, + "interface_schema_version": 46, "operations": [ { "capability": "standards.snapshot.create", @@ -10398,6 +10642,6 @@ } ], "request_contract_version": 6, - "result_projection_version": 7, + "result_projection_version": 8, "schema_version": 1 } diff --git a/tools/standards_engine/standards_engine/_generated_contract.py b/tools/standards_engine/standards_engine/_generated_contract.py index acc2018b..ff1441ec 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},"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"],"properties":{"kind":{"const":"apply-proposal-result"},"application":{"$ref":"#/$defs/ApplicationHandle"},"status":{"const":"applied"}},"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"],"properties":{"kind":{"const":"recover-application-result"},"application":{"$ref":"#/$defs/ApplicationHandle"},"status":{"const":"applied"}},"additionalProperties":false},"ApplicationRecoveryRequiredResult":{"type":"object","required":["kind","application","status","code","outcome","message"],"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_PERSISTENCE_UNAVAILABLE","APPLICATION.RECOVERY_TARGET_UNCERTAIN","APPLICATION.RECOVERY_TARGET_DIVERGED","APPLICATION.RECOVERY_BLOCKED"]},"outcome":{"const":"unavailable"},"message":{"$ref":"#/$defs/NonEmptyString"},"details":{"type":"object","additionalProperties":{"$ref":"#/$defs/ScalarValue"}}},"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}}},"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":{"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"},"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}}}, '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}, '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}}}, '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': {}}, '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': {'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}}}, '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}}}, '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}}}, '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}, '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}}},"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":{"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': {}}, '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': {'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}}}}) @dataclass(frozen=True, slots=True) class ActiveSnapshotSummary: @@ -1065,6 +1065,42 @@ def from_value(cls, value: object) -> ApplicationPolicy: def as_contract(self) -> dict[str, object]: return model_as_contract(self) +@dataclass(frozen=True, slots=True) +class ApplicationPublicationReceipt: + 'Durable application identity and exact candidate facts, separate from the fresh target observation.' + __definition__: ClassVar[str] = 'ApplicationPublicationReceipt' + __contract_fields__: ClassVar = MappingProxyType({ + 'kind': 'kind', + 'application': 'application', + 'candidate_commit': 'candidate_commit', + 'candidate_tree': 'candidate_tree', + 'target_ref': 'target_ref', + 'expected_predecessor': 'expected_predecessor', + 'durable_state': 'durable_state', + 'target_observation': 'target_observation', + }) + kind: Literal['application-publication-receipt'] + application: ApplicationHandle + candidate_commit: GitObjectId + candidate_tree: GitObjectId | None + target_ref: Literal['refs/heads/main'] + expected_predecessor: GitObjectId + durable_state: Literal['applied', 'admitted', 'unknown'] + target_observation: PublicationTargetObservation + + def __post_init__(self) -> None: + _RUNTIME.normalize_model(self) + + @classmethod + def from_value(cls, value: object) -> ApplicationPublicationReceipt: + selected = _RUNTIME.decode(cls.__definition__, value) + if not isinstance(selected, cls): + raise TypeError('decoded value has the wrong generated type') + return selected + + def as_contract(self) -> dict[str, object]: + return model_as_contract(self) + @dataclass(frozen=True, slots=True) class ApplicationQueryCall: '' @@ -1318,14 +1354,18 @@ class ApplicationRecoveryRequiredResult: 'code': 'code', 'outcome': 'outcome', 'message': 'message', + 'publication': 'publication', + 'checkout': 'checkout', 'details': 'details', }) kind: Literal['application-recovery-required-result'] application: ApplicationHandle status: Literal['recovery-required'] - code: Literal['APPLICATION.PUBLICATION_UNAVAILABLE', 'APPLICATION.OBSERVATION_UNAVAILABLE', 'APPLICATION.OUTCOME_PERSISTENCE_UNAVAILABLE', 'APPLICATION.RECOVERY_TARGET_UNCERTAIN', 'APPLICATION.RECOVERY_TARGET_DIVERGED', 'APPLICATION.RECOVERY_BLOCKED'] + code: Literal['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: Literal['unavailable'] message: NonEmptyString + publication: ApplicationPublicationReceipt + checkout: PublicationCheckoutObservation details: FrozenMap[str, ScalarValue] | MissingValue = MISSING def __post_init__(self) -> None: @@ -1591,10 +1631,14 @@ class ApplyProposalResult: 'kind': 'kind', 'application': 'application', 'status': 'status', + 'publication': 'publication', + 'checkout': 'checkout', }) kind: Literal['apply-proposal-result'] application: ApplicationHandle status: Literal['applied'] + publication: ApplicationPublicationReceipt + checkout: PublicationCheckoutObservation def __post_init__(self) -> None: _RUNTIME.normalize_model(self) @@ -5169,6 +5213,96 @@ def from_value(cls, value: object) -> ProviderReference: def as_contract(self) -> dict[str, object]: return model_as_contract(self) +@dataclass(frozen=True, slots=True) +class PublicationCheckoutObservation: + 'Fresh read-only observation of one selected checkout. Unavailable observations use null for every fact that could not be established.' + __definition__: ClassVar[str] = 'PublicationCheckoutObservation' + __contract_fields__: ClassVar = MappingProxyType({ + 'kind': 'kind', + 'status': 'status', + 'worktree_id': 'worktree_id', + 'symbolic_branch': 'symbolic_branch', + 'head': 'head', + 'index_observation': 'index_observation', + 'publication_path_count': 'publication_path_count', + 'index_paths': 'index_paths', + 'worktree_paths': 'worktree_paths', + }) + kind: Literal['publication-checkout-observation'] + status: Literal['not-observed', 'unavailable', 'not-target-checkout', 'current', 'needs-reconciliation', 'conflicted'] + worktree_id: Digest | None + symbolic_branch: NonEmptyString | None + head: GitObjectId | None + index_observation: Digest | None + publication_path_count: object + index_paths: PublicationPathCounts + worktree_paths: PublicationPathCounts + + def __post_init__(self) -> None: + _RUNTIME.normalize_model(self) + + @classmethod + def from_value(cls, value: object) -> PublicationCheckoutObservation: + selected = _RUNTIME.decode(cls.__definition__, value) + if not isinstance(selected, cls): + raise TypeError('decoded value has the wrong generated type') + return selected + + def as_contract(self) -> dict[str, object]: + return model_as_contract(self) + +@dataclass(frozen=True, slots=True) +class PublicationPathCounts: + '' + __definition__: ClassVar[str] = 'PublicationPathCounts' + __contract_fields__: ClassVar = MappingProxyType({ + 'predecessor': 'predecessor', + 'candidate': 'candidate', + 'conflicted': 'conflicted', + }) + predecessor: object + candidate: object + conflicted: object + + def __post_init__(self) -> None: + _RUNTIME.normalize_model(self) + + @classmethod + def from_value(cls, value: object) -> PublicationPathCounts: + selected = _RUNTIME.decode(cls.__definition__, value) + if not isinstance(selected, cls): + raise TypeError('decoded value has the wrong generated type') + return selected + + def as_contract(self) -> dict[str, object]: + return model_as_contract(self) + +@dataclass(frozen=True, slots=True) +class PublicationTargetObservation: + 'Fresh bounded observation of the configured target ref; an unavailable revision is null.' + __definition__: ClassVar[str] = 'PublicationTargetObservation' + __contract_fields__: ClassVar = MappingProxyType({ + 'kind': 'kind', + 'status': 'status', + 'revision': 'revision', + }) + kind: Literal['publication-target-observation'] + status: Literal['candidate', 'expected', 'diverged', 'unavailable'] + revision: GitObjectId | None + + def __post_init__(self) -> None: + _RUNTIME.normalize_model(self) + + @classmethod + def from_value(cls, value: object) -> PublicationTargetObservation: + selected = _RUNTIME.decode(cls.__definition__, value) + if not isinstance(selected, cls): + raise TypeError('decoded value has the wrong generated type') + return selected + + def as_contract(self) -> dict[str, object]: + return model_as_contract(self) + @dataclass(frozen=True, slots=True) class PutDecisionProvenanceEdit: '' @@ -5727,10 +5861,14 @@ class RecoverApplicationResult: 'kind': 'kind', 'application': 'application', 'status': 'status', + 'publication': 'publication', + 'checkout': 'checkout', }) kind: Literal['recover-application-result'] application: ApplicationHandle status: Literal['applied'] + publication: ApplicationPublicationReceipt + checkout: PublicationCheckoutObservation def __post_init__(self) -> None: _RUNTIME.normalize_model(self) @@ -7912,6 +8050,8 @@ class WorkflowResult: 'context': 'context', 'proposal': 'proposal', 'revision': 'revision', + 'publication': 'publication', + 'checkout': 'checkout', 'status': 'status', 'next_operations': 'next_operations', 'outcome': 'outcome', @@ -7923,6 +8063,8 @@ class WorkflowResult: revision: ProposalRevisionHandle status: Literal['draft', 'needs-action', 'complete', 'requires-change', 'ready', 'recovery-required', 'applied', 'rejected', 'stale'] next_operations: tuple[WorkflowContinuation, ...] + publication: ApplicationPublicationReceipt | MissingValue = MISSING + checkout: PublicationCheckoutObservation | MissingValue = MISSING outcome: WorkflowOutcome | MissingValue = MISSING work: WorkflowWorkPage | WorkflowWorkDeferred | MissingValue = MISSING @@ -8069,6 +8211,7 @@ def as_contract(self) -> dict[str, object]: FactRequirementId: TypeAlias = str FactValue: TypeAlias = FrozenMap[str, object] FactSet: TypeAlias = FrozenMap[str, FactValue] +GitObjectId: TypeAlias = str ImpactTraceId: TypeAlias = str InspectableHandle: TypeAlias = SnapshotHandle | AnalysisHandle | SnapshotChildHandle | AnalysisChildHandle InspectionResult: TypeAlias = SnapshotInspectionResult | PolicyInspectionResult | RelationshipInspectionResult | AnalysisInspectionResult | AnalysisChildInspectionResult @@ -8141,6 +8284,7 @@ def as_contract(self) -> dict[str, object]: 'ApplicationInspectCall': ApplicationInspectCall, 'ApplicationNextOperation': ApplicationNextOperation, 'ApplicationPolicy': ApplicationPolicy, + 'ApplicationPublicationReceipt': ApplicationPublicationReceipt, 'ApplicationQueryCall': ApplicationQueryCall, 'ApplicationQuestion': ApplicationQuestion, 'ApplicationReadCall': ApplicationReadCall, @@ -8277,6 +8421,9 @@ def as_contract(self) -> dict[str, object]: 'ProvenanceRecord': ProvenanceRecord, 'ProvideFactSubmission': ProvideFactSubmission, 'ProviderReference': ProviderReference, + 'PublicationCheckoutObservation': PublicationCheckoutObservation, + 'PublicationPathCounts': PublicationPathCounts, + 'PublicationTargetObservation': PublicationTargetObservation, 'PutDecisionProvenanceEdit': PutDecisionProvenanceEdit, 'PutPolicyRelationshipEdit': PutPolicyRelationshipEdit, 'PutRoutingFactEdit': PutRoutingFactEdit, @@ -8434,6 +8581,7 @@ def decode_contract(definition: str, value: object) -> object: 'ApplicationInspectCall', 'ApplicationNextOperation', 'ApplicationPolicy', + 'ApplicationPublicationReceipt', 'ApplicationQueryCall', 'ApplicationQueryRequest', 'ApplicationQuestion', @@ -8528,6 +8676,7 @@ def decode_contract(definition: str, value: object) -> object: 'FindSnapshotsResult', 'FocusedQueryNextOperation', 'GeneralSelectionReason', + 'GitObjectId', 'ImpactDispositionSubmission', 'ImpactTraceId', 'ImpactTraceReference', @@ -8589,6 +8738,9 @@ def decode_contract(definition: str, value: object) -> object: 'ProvenanceRecord', 'ProvideFactSubmission', 'ProviderReference', + 'PublicationCheckoutObservation', + 'PublicationPathCounts', + 'PublicationTargetObservation', 'PutDecisionProvenanceEdit', 'PutPolicyRelationshipEdit', 'PutRoutingFactEdit', diff --git a/tools/standards_engine/standards_engine/agent_workflow.py b/tools/standards_engine/standards_engine/agent_workflow.py index 205d0184..21f5680c 100644 --- a/tools/standards_engine/standards_engine/agent_workflow.py +++ b/tools/standards_engine/standards_engine/agent_workflow.py @@ -110,7 +110,11 @@ def publication_status(engine, readiness): if error.failure.code != "APPLICATION.NOT_ADMITTED": raise return "ready" - return "applied" if engine._authoring.application_outcome(application) is not None else "recovery-required" + try: + outcome = engine._authoring.application_outcome(application) + except Exception: + return "recovery-required" + return "applied" if outcome is not None else "recovery-required" def view(engine, bound, outcome=None, materials: ProposalMaterials | None = None, *, detail="compact", include_work=False): @@ -151,12 +155,35 @@ def view(engine, bound, outcome=None, materials: ProposalMaterials | None = None ) if current.revision_id != bound.revision.revision_id: status = "stale" + publication_fields = {} + if ( + bound.readiness is not None + and status in ("recovery-required", "applied") + and not isinstance( + outcome, + ( + c.ApplyProposalResult, + c.RecoverApplicationResult, + c.ApplicationRecoveryRequiredResult, + ), + ) + ): + try: + application = engine._authoring.read_selected_application( + bound.readiness.readiness_id + ) + except AuthoringError as error: + if error.failure.code != "APPLICATION.NOT_ADMITTED": + raise + else: + publication_fields = engine._application_publication_projection(application) result = { "kind": "workflow-result", "context": context, "proposal": engine._proposal_handle(bound.revision.proposal), "revision": engine._proposal_revision_handle(bound.revision.revision_id), "status": status, + **publication_fields, "next_operations": [ { "operation": operation, diff --git a/tools/standards_engine/standards_engine/engine.py b/tools/standards_engine/standards_engine/engine.py index 679f0bd5..aeedaf5f 100644 --- a/tools/standards_engine/standards_engine/engine.py +++ b/tools/standards_engine/standards_engine/engine.py @@ -287,6 +287,22 @@ class _EvaluationMaterials: revision_decoding: RevisionDecoding | None = field(default=None, compare=False, repr=False) +@dataclass(frozen=True, slots=True) +class _CoveragePublicationPreparation: + """Exact destination evidence inputs validated without publication authority.""" + + subjects: tuple[str, ...] + analysis_id: str + claims: Mapping[str, Mapping[str, object]] + authorizations: Mapping[str, Mapping[str, object]] + registry: Mapping[str, object] + receipt_paths: frozenset[str] + source_files: Mapping[str, bytes] + source_paths: frozenset[str] + base_files: Mapping[str, bytes] + original_captured_paths: frozenset[str] + + class _GitRevisionSource: def __init__(self, reader: RevisionReadSession) -> None: self._reader = reader @@ -1275,7 +1291,9 @@ def review_proposal( "Proposal review requires analysis of an immutable proposal revision.", ) revision = self._authoring.read_revision(proposed.revision_id) - target = self._repository.branch_revision(CANONICAL_TARGET_BRANCH) + target = self._repository.branch_revision( + CANONICAL_TARGET_BRANCH, local_only=True + ) base = self._snapshots.snapshot(revision.base_snapshot) if target.oid != base.source_revision: return self._reject( @@ -1283,6 +1301,12 @@ def review_proposal( "unavailable", "The configured main branch no longer matches the proposal base.", ) + self._preflight_proposal_coverage( + state, + revision, + target, + phase="readiness-preflight", + ) decisions = tuple(item.as_contract() for item in call.decisions) authorizations = tuple( construct_authorization_record( @@ -1399,6 +1423,7 @@ def apply_proposal( application.application_id ), "status": "applied", + **self._application_publication_projection(application), } ) except self._domain_errors() as error: @@ -1545,14 +1570,140 @@ def _publish_coverage_into_candidate( ) from .logical_authoring import _refresh_suite_input_projection - subjects = self._coverage_audit_subjects(revision) - if not subjects: + preparation = self._prepare_coverage_publication( + readiness.analysis_id, + revision, + projection, + readiness.expected_target, + base_files, + proposed_files, + proposed_paths, + phase="candidate-evidence", + ) + if preparation is None: + return + proposed_files.clear() + proposed_files.update(preparation.source_files) + proposed_paths.update(preparation.source_paths) + base_files.clear() + base_files.update(preparation.base_files) + registry = dict(preparation.registry) + receipt_paths = set(preparation.receipt_paths) + for subject in preparation.subjects: + claim = preparation.claims[subject] + authorization = preparation.authorizations[claim["authorization_id"]] + receipt = render_engine_coverage_receipt( + FrozenContentSource(preparation.source_files), + projection.compiled.coverage, + subject, + claim, + authorization, + preparation.analysis_id, + self._execution_context, + phase="candidate-evidence", + source_kind="repository-content", + material_identity=revision.revision_id, + ) + path = self._engine_coverage_receipt_path(subject) + if path in proposed_paths and path not in proposed_files: + raise AnalysisError( + AnalysisFailure( + "COVERAGE.PUBLICATION_PATH_CONFLICT", + "invalid", + "The Engine receipt path is occupied outside captured authority.", + ) + ) + proposed_files[path] = receipt + proposed_paths.add(path) + receipt_paths.add(path) + registry["schema_version"] = 3 + registry["engine_sources"] = sorted(receipt_paths) + proposed_files["evaluation/standards-effectiveness/policy-coverage/attestation-sources.toml"] = ( + "schema_version = 3\n" + + "\n".join( + key + + " = [\n" + + "".join( + " " + json.dumps(path, ensure_ascii=False) + ",\n" + for path in registry[key] + ) + + "]\n" + for key in ("sources", "engine_sources") + ) + ).encode("utf-8") + proposed_paths.update( + _refresh_suite_input_projection( + proposed_files, + preparation.original_captured_paths, + revision.base_repository_paths, + ) + ) + final = self._compile(FrozenContentSource(proposed_files)) + if not set(preparation.subjects) <= final.repository_coverage.covered_subjects: + raise AnalysisError( + AnalysisFailure( + "COVERAGE.PUBLICATION_STALE", + "invalid", + "Publication changed the reviewed coverage requirement; a fresh review is required.", + ) + ) + + def _preflight_proposal_coverage( + self, + state: DomainAnalysisState, + revision: ProposalRevision, + expected_target: RepositoryRevision, + *, + phase: str, + ) -> None: + if not self._coverage_audit_subjects(revision): return - state = self._load_analysis( - AnalysisHandle.from_value(self._analysis_handle(readiness.analysis_id)) + projection = self._proposal_projection(revision) + capture = self._snapshots.load_content(revision.base_snapshot) + base_files = {str(item.path): item.content for item in capture.files} + base_files.update(projection.captured_consumer_files) + proposed_files = dict(projection.source.files) + proposed_paths = set(projection.repository_paths) + self._prepare_coverage_publication( + state.analysis_id, + revision, + projection, + expected_target, + base_files, + proposed_files, + proposed_paths, + phase=phase, + state=state, ) + + def _prepare_coverage_publication( + self, + analysis_id: str, + revision: ProposalRevision, + projection: LogicalProjection, + expected_target: RepositoryRevision, + base_files: Mapping[str, bytes], + proposed_files: Mapping[str, bytes], + proposed_paths: set[str], + *, + phase: str, + state: DomainAnalysisState | None = None, + ) -> _CoveragePublicationPreparation | None: + """Validate one exact destination source without writing or authorizing.""" + from tools.standards_analysis.standards_analysis import ( + validate_engine_coverage_receipt_evidence, + ) + + subjects = self._coverage_audit_subjects(revision) + if not subjects: + return None + if state is None: + state = self._load_analysis( + AnalysisHandle.from_value(self._analysis_handle(analysis_id)) + ) if ( - not isinstance(state.proposed_material, ProjectedRevisionMaterialRef) + state.analysis_id != analysis_id + or not isinstance(state.proposed_material, ProjectedRevisionMaterialRef) or state.proposed_material.revision_id != revision.revision_id or state.base_snapshot != revision.base_snapshot ): @@ -1572,7 +1723,7 @@ def _publish_coverage_into_candidate( "Coverage publication requires a complete reviewed Analysis.", ) ) - claims = { + claims_by_requirement = { self._plain(item)["requirement_id"]: self._plain(item) for item in state.coverage_attestations } @@ -1580,16 +1731,33 @@ def _publish_coverage_into_candidate( self._plain(item)["reference"]["id"]: self._plain(item) for item in state.authorization_records } - registry_path = "evaluation/standards-effectiveness/policy-coverage/attestation-sources.toml" - registry = tomllib.loads(proposed_files[registry_path].decode("utf-8")) - receipt_paths = set(registry.get("engine_sources", [])) + source_files = dict(proposed_files) + source_paths = set(proposed_paths) + destination_base_files = dict(base_files) original_captured_paths = frozenset(base_files) + registry_path = "evaluation/standards-effectiveness/policy-coverage/attestation-sources.toml" + try: + registry = tomllib.loads(source_files[registry_path].decode("utf-8")) + except (KeyError, UnicodeDecodeError, tomllib.TOMLDecodeError) as error: + raise AnalysisError(AnalysisFailure( + "COVERAGE.PUBLICATION_REGISTRY_INVALID", + "invalid", + "The destination coverage source registry is unavailable or invalid.", + )) from error + receipt_paths = frozenset(registry.get("engine_sources", [])) + overwritten_paths = { + registry_path, + "evaluation/standards-effectiveness/generated/suite-inputs.json", + *(self._engine_coverage_receipt_path(subject) for subject in subjects), + } + claims: dict[str, Mapping[str, object]] = {} + subjects_for_claim: dict[str, str] = {} for subject in subjects: requirement = coverage_requirement_id( projection.compiled.coverage.requirements[subject], projection.compiled.coverage.views[subject], ) - claim = claims.get(requirement) + claim = claims_by_requirement.get(requirement) if claim is None or claim["authorization_id"] not in authorizations: raise AnalysisError( AnalysisFailure( @@ -1600,76 +1768,102 @@ def _publish_coverage_into_candidate( ) for reference in (*claim["evidence"], *claim["explicit_exclusions"]): path = reference["id"] - if path not in proposed_files: - if path not in proposed_paths: - raise AnalysisError( - AnalysisFailure( - "COVERAGE.PUBLICATION_EVIDENCE_UNCOMMITTED", - "unavailable", - "Published review evidence must exist in the destination repository.", - ) + if path in overwritten_paths: + raise AnalysisError(AnalysisFailure( + "COVERAGE.PUBLICATION_EVIDENCE_OVERWRITTEN", + "invalid", + "Selected review evidence would be overwritten by coverage publication.", + validation_phase=phase, + evidence_reference=path, + provider_contract=reference["provider_contract"], + provider_contract_version=reference["provider_contract_version"], + source_kind="repository-content", + material_identity=revision.revision_id, + expected_digest=reference["digest"], + next_action="select-stable-review-evidence", + )) + if path in source_files: + continue + if path not in source_paths: + removed_from_candidate = path in revision.base_repository_paths + failure = AnalysisFailure( + "COVERAGE.PUBLICATION_EVIDENCE_REMOVED" + if removed_from_candidate + else "COVERAGE.PUBLICATION_EVIDENCE_UNCOMMITTED", + "unavailable", + "Published review evidence is absent from the destination candidate.", + validation_phase=phase, + evidence_reference=path, + provider_contract=reference["provider_contract"], + provider_contract_version=reference["provider_contract_version"], + source_kind="repository-content", + material_identity=revision.revision_id, + expected_digest=reference["digest"], + next_action=( + "restore-reference-to-candidate" + if removed_from_candidate + else "include-reference-in-proposal" + ), + ) + raise AnalysisError(failure) + try: + content = ( + base_files[path] + if path in base_files + else self._repository.read_file( + expected_target, RepositoryPath.parse(path) ) - content = self._repository.read_file( - readiness.expected_target, RepositoryPath.parse(path) ) - base_files[path] = content - proposed_files[path] = content - receipt = render_engine_coverage_receipt( - FrozenContentSource(proposed_files), + except GitRepositoryError as error: + raise AnalysisError(AnalysisFailure( + "COVERAGE.PUBLICATION_EVIDENCE_UNAVAILABLE", + "unavailable", + "The selected destination evidence could not be read.", + validation_phase=phase, + evidence_reference=path, + provider_contract=reference["provider_contract"], + provider_contract_version=reference["provider_contract_version"], + source_kind="repository-content", + material_identity=expected_target.oid, + expected_digest=reference["digest"], + next_action="restore-or-rebind-evidence", + )) from error + source_files[path] = content + if path in revision.base_repository_paths: + destination_base_files[path] = content + validate_engine_coverage_receipt_evidence( + FrozenContentSource(source_files), projection.compiled.coverage, subject, claim, authorizations[claim["authorization_id"]], - state.analysis_id, - self._execution_context, - ) - path = ( - "evaluation/standards-effectiveness/policy-coverage/engine/" - + analysis_value_digest(subject).removeprefix("sha256:") - + ".json" - ) - if path in proposed_paths and path not in proposed_files: - raise AnalysisError( - AnalysisFailure( - "COVERAGE.PUBLICATION_PATH_CONFLICT", - "invalid", - "The Engine receipt path is occupied outside captured authority.", - ) - ) - proposed_files[path] = receipt - proposed_paths.add(path) - receipt_paths.add(path) - registry["schema_version"] = 3 - registry["engine_sources"] = sorted(receipt_paths) - proposed_files[registry_path] = ( - "schema_version = 3\n" - + "\n".join( - key - + " = [\n" - + "".join( - " " + json.dumps(path, ensure_ascii=False) + ",\n" - for path in registry[key] - ) - + "]\n" - for key in ("sources", "engine_sources") - ) - ).encode("utf-8") - proposed_paths.update( - _refresh_suite_input_projection( - proposed_files, - original_captured_paths, - revision.base_repository_paths, - ) + analysis_id, + phase=phase, + source_kind="repository-content", + material_identity=revision.revision_id, + next_action="refresh-review-evidence", + ) + claims[subject] = claim + return _CoveragePublicationPreparation( + subjects=subjects, + analysis_id=analysis_id, + claims=claims, + authorizations=authorizations, + registry=registry, + receipt_paths=receipt_paths, + source_files=source_files, + source_paths=frozenset(source_paths), + base_files=destination_base_files, + original_captured_paths=original_captured_paths, + ) + + @staticmethod + def _engine_coverage_receipt_path(subject: str) -> str: + return ( + "evaluation/standards-effectiveness/policy-coverage/engine/" + + analysis_value_digest(subject).removeprefix("sha256:") + + ".json" ) - final = self._compile(FrozenContentSource(proposed_files)) - if not set(subjects) <= final.repository_coverage.covered_subjects: - raise AnalysisError( - AnalysisFailure( - "COVERAGE.PUBLICATION_STALE", - "invalid", - "Publication changed the reviewed coverage requirement; a fresh review is required.", - ) - ) @staticmethod def _coverage_audit_subjects(revision: ProposalRevision) -> tuple[str, ...]: @@ -1708,7 +1902,16 @@ def recover_application( application = self._authoring.read_selected_application( readiness.readiness_id ) - if self._authoring.application_outcome(application) is not None: + try: + prior_outcome = self._authoring.application_outcome(application) + except self._domain_errors() as error: + return self._application_recovery_required( + application, + "APPLICATION.OUTCOME_OBSERVATION_UNAVAILABLE", + "The durable application outcome could not be observed during recovery.", + details=_recovery_failure_details(error), + ) + if prior_outcome is not None: return self._recovered_application(application) try: observed = self._repository.branch_revision(CANONICAL_TARGET_BRANCH) @@ -3387,9 +3590,8 @@ def _application_handle(application: str) -> dict[str, object]: "schema_version": 1, } - @classmethod def _application_recovery_required( - cls, + self, application: ProposalApplication, code: str, message: str, @@ -3399,27 +3601,116 @@ def _application_recovery_required( return ApplicationRecoveryRequiredResult.from_value( { "kind": "application-recovery-required-result", - "application": cls._application_handle(application.application_id), + "application": self._application_handle(application.application_id), "status": "recovery-required", "code": code, "outcome": "unavailable", "message": message, + **self._application_publication_projection(application), **({"details": dict(details)} if details is not None else {}), } ) - @classmethod def _recovered_application( - cls, application: ProposalApplication + self, application: ProposalApplication ) -> RecoverApplicationResult: return RecoverApplicationResult.from_value( { "kind": "recover-application-result", - "application": cls._application_handle(application.application_id), + "application": self._application_handle(application.application_id), "status": "applied", + **self._application_publication_projection(application), } ) + def _application_publication_projection( + self, application: ProposalApplication, + ) -> dict[str, object]: + """Return durable publication identity plus fresh, bounded observations.""" + try: + outcome = self._authoring.application_outcome(application) + durable_state = "applied" if outcome is not None else "admitted" + except Exception: + durable_state = "unknown" + + try: + target = self._repository.branch_revision( + CANONICAL_TARGET_BRANCH, local_only=True + ) + target_status = ( + "candidate" if target == application.candidate + else "expected" if target == application.expected_target + else "diverged" + ) + target_revision: str | None = target.oid + except GitRepositoryError: + target_status = "unavailable" + target_revision = None + + try: + candidate_tree: str | None = self._repository.revision_tree( + application.candidate, local_only=True + ) + except GitRepositoryError: + candidate_tree = None + + publication = { + "kind": "application-publication-receipt", + "application": self._application_handle(application.application_id), + "candidate_commit": application.candidate.oid, + "candidate_tree": candidate_tree, + "target_ref": "refs/heads/" + CANONICAL_TARGET_BRANCH, + "expected_predecessor": application.expected_target.oid, + "durable_state": durable_state, + "target_observation": { + "kind": "publication-target-observation", + "status": target_status, + "revision": target_revision, + }, + } + try: + observation = self._repository.observe_publication_checkout( + application.expected_target, application.candidate, + target_ref="refs/heads/" + CANONICAL_TARGET_BRANCH, + ) + except Exception: + checkout: dict[str, object] = { + "kind": "publication-checkout-observation", + "status": "unavailable", + "worktree_id": None, + "symbolic_branch": None, + "head": None, + "index_observation": None, + "publication_path_count": None, + "index_paths": { + "predecessor": None, "candidate": None, "conflicted": None, + }, + "worktree_paths": { + "predecessor": None, "candidate": None, "conflicted": None, + }, + } + else: + checkout = { + "kind": "publication-checkout-observation", + "status": observation.status, + "worktree_id": "sha256:" + observation.worktree_id, + "symbolic_branch": observation.symbolic_branch, + "head": observation.head.oid, + "index_observation": "sha256:" + observation.index_digest, + "publication_path_count": observation.publication_path_count, + "index_paths": { + "predecessor": observation.index_predecessor_count, + "candidate": observation.index_candidate_count, + "conflicted": observation.index_conflict_count, + }, + "worktree_paths": { + "predecessor": observation.worktree_predecessor_count, + "candidate": observation.worktree_candidate_count, + "conflicted": observation.worktree_conflict_count, + }, + } + return {"publication": publication, "checkout": checkout} + @classmethod def _proposal_summary(cls, summary: AuthoringProposalSummary) -> dict[str, object]: return { @@ -3457,17 +3748,16 @@ def _domain_errors() -> tuple[type[Exception], ...]: VerificationError, ) - @classmethod - def _domain_rejection(cls, error: Exception) -> RejectedResult: + def _domain_rejection(self, error: Exception) -> RejectedResult: if isinstance(error, VerificationError): diagnostic = error.diagnostic - return cls._reject( + return self._reject( diagnostic.code, diagnostic.outcome, diagnostic.message, details={key: value for key, value in diagnostic.as_dict().items() if key not in {"code", "outcome", "message"}}, ) if isinstance(error, GitRepositoryError) and error.failure.command is not None: - return cls._reject( + return self._reject( error.failure.code, error.failure.kind, "The Git command failed; inspect the bounded command observation.", details=_recovery_failure_details(error), @@ -3476,7 +3766,67 @@ def _domain_rejection(cls, error: Exception) -> RejectedResult: if failure is None: raise error outcome = getattr(failure, "outcome", getattr(failure, "kind", "invalid")) - return cls._reject(failure.code, outcome, failure.message) + details: dict[str, object] = {} + if self._purpose is Purpose.AUTHORING and isinstance( + failure, AnalysisFailure + ): + for key, value, max_length, allowed_punctuation in ( + ("path", failure.path, 512, "._:/- []"), + ("field", failure.field, 128, "._:/-[]"), + ("observed", failure.observed, 128, "._:/-|"), + ): + if ( + type(value) is not str + or not value + or len(value) > max_length + or not value[0].isascii() + or not value[0].isalnum() + or any( + not character.isascii() + or not ( + character.isalnum() + or character in allowed_punctuation + ) + for character in value + ) + ): + continue + if key == "path" and ( + value.startswith(("/", "\\")) + or ( + len(value) >= 3 + and value[0].isalpha() + and value[1:3] in {":/", ":\\"} + ) + or any( + part in {"", ".", ".."} + for part in value.replace("\\", "/").split("/") + ) + ): + continue + details[key] = value + + if ( + self._purpose is Purpose.AUTHORING + and isinstance(failure, AnalysisFailure) + and failure.validation_phase is not None + ): + for key, value in ( + ("validation_phase", failure.validation_phase), + ("evidence_reference", failure.evidence_reference), + ("provider_contract", failure.provider_contract), + ("provider_contract_version", failure.provider_contract_version), + ("source_kind", failure.source_kind), + ("material_identity", failure.material_identity), + ("expected_digest", failure.expected_digest), + ("observed_digest", failure.observed_digest), + ("next_action", failure.next_action), + ): + if _bounded_analysis_diagnostic(key, value): + details[key] = value + return self._reject( + failure.code, outcome, failure.message, details=details or None + ) @classmethod def _analysis_unavailable(cls) -> RejectedResult: @@ -3506,6 +3856,47 @@ def _reject( ) +def _bounded_analysis_diagnostic(field: str, value: object) -> bool: + """Admit complete useful values; never expose unbounded or partial identities.""" + limits = { + "validation_phase": 64, + "evidence_reference": 1024, + "provider_contract": 128, + "provider_contract_version": 64, + "source_kind": 64, + "material_identity": 256, + "expected_digest": 71, + "observed_digest": 71, + "next_action": 128, + } + if type(value) is not str or not 0 < len(value) <= limits[field]: + return False + if field == "evidence_reference": + return ( + value.isprintable() + and not value.startswith("/") + and "\\" not in value + and not (len(value) >= 2 and value[1] == ":") + and all(part not in {"", ".", ".."} for part in value.split("/")) + ) + if field in {"expected_digest", "observed_digest"}: + return ( + value.startswith("sha256:") + and len(value) == 71 + and all(character in "0123456789abcdef" for character in value[7:]) + ) + punctuation = "._-" if field in { + "validation_phase", "provider_contract", "provider_contract_version", + "source_kind", "next_action", + } else "._:/-" + if not ( + value.isascii() and value[0].isalnum() + and all(character.isalnum() or character in punctuation for character in value) + ): + return False + return True + + def _recovery_failure_details(error: Exception) -> dict[str, object]: """Project owned diagnostic fields, preserving raw error text privately.""" failure = getattr(error, "failure", None) diff --git a/tools/standards_engine/tests/test_agent_workflow.py b/tools/standards_engine/tests/test_agent_workflow.py index fa56738e..9f4f7201 100644 --- a/tools/standards_engine/tests/test_agent_workflow.py +++ b/tools/standards_engine/tests/test_agent_workflow.py @@ -228,12 +228,39 @@ def test_review_is_explicit_and_current_authorization_is_required(self): "id": "application:sha256:" + "a" * 64, "schema_version": 1, } + publication = { + "kind": "application-publication-receipt", + "application": application, + "candidate_commit": "1" * 40, + "candidate_tree": "2" * 40, + "target_ref": "refs/heads/main", + "expected_predecessor": "3" * 40, + "durable_state": "applied", + "target_observation": { + "kind": "publication-target-observation", + "status": "candidate", + "revision": "1" * 40, + }, + } + checkout = { + "kind": "publication-checkout-observation", + "status": "current", + "worktree_id": "sha256:" + "d" * 64, + "symbolic_branch": "refs/heads/main", + "head": "1" * 40, + "index_observation": "sha256:" + "e" * 64, + "publication_path_count": 1, + "index_paths": {"predecessor": 0, "candidate": 1, "conflicted": 0}, + "worktree_paths": {"predecessor": 0, "candidate": 1, "conflicted": 0}, + } outcomes = [ c.ApplyProposalResult.from_value( { "kind": "apply-proposal-result", "application": application, "status": "applied", + "publication": publication, + "checkout": checkout, } ), c.RecoverApplicationResult.from_value( @@ -241,6 +268,8 @@ def test_review_is_explicit_and_current_authorization_is_required(self): "kind": "recover-application-result", "application": application, "status": "applied", + "publication": publication, + "checkout": checkout, } ), c.ApplicationRecoveryRequiredResult.from_value( @@ -251,6 +280,8 @@ def test_review_is_explicit_and_current_authorization_is_required(self): "code": "APPLICATION.OUTCOME_PERSISTENCE_UNAVAILABLE", "outcome": "unavailable", "message": "Fixture interrupted outcome recording", + "publication": {**publication, "durable_state": "admitted"}, + "checkout": checkout, } ), ] diff --git a/tools/standards_engine/tests/test_analysis.py b/tools/standards_engine/tests/test_analysis.py index f547323b..237f5f8b 100644 --- a/tools/standards_engine/tests/test_analysis.py +++ b/tools/standards_engine/tests/test_analysis.py @@ -13,6 +13,8 @@ from unittest import mock from tools.standards_analysis.standards_analysis import ( + AnalysisError, + AnalysisFailure, AnalysisState as DomainAnalysisState, AnalysisExecutionContext, AuthorizationAuthorityContract, @@ -40,6 +42,7 @@ InspectCall, PendingResult, PrepareCall, + Purpose, RejectedResult, RecoverApplicationResult, ResolveCall, @@ -267,6 +270,64 @@ def authorize(self, request): class AnalysisWorkflowTest(unittest.TestCase): + def test_publication_projection_uses_local_target_and_bounds_unavailable_observation(self): + application = mock.Mock( + application_id="application:sha256:" + "a" * 64, + expected_target=RepositoryRevision("b" * 40), + candidate=RepositoryRevision("c" * 40), + ) + unavailable = GitRepositoryError(GitRepositoryFailure( + "unavailable", "REPOSITORY_GIT.COMMAND_UNAVAILABLE", + "/tmp/private-publication/secret: " + "x" * 4096, + )) + with ( + mock.patch.object( + self.engine._authoring, "application_outcome", return_value=None + ) as outcome, + mock.patch.object( + self.engine._repository, "branch_revision", side_effect=unavailable + ) as target, + mock.patch.object( + self.engine._repository, "revision_tree", return_value="d" * 40 + ) as tree, + mock.patch.object( + self.engine._repository, "observe_publication_checkout", + side_effect=unavailable, + ) as checkout, + ): + projection = self.engine._application_publication_projection(application) + outcome.assert_called_once_with(application) + target.assert_called_once_with("main", local_only=True) + tree.assert_called_once_with(application.candidate, local_only=True) + checkout.assert_called_once_with( + application.expected_target, application.candidate, target_ref="refs/heads/main" + ) + self.assertEqual(projection, { + "publication": { + "kind": "application-publication-receipt", + "application": { + "kind": "application-handle", "id": application.application_id, + "schema_version": 1, + }, + "candidate_commit": "c" * 40, + "candidate_tree": "d" * 40, + "target_ref": "refs/heads/main", + "expected_predecessor": "b" * 40, + "durable_state": "admitted", + "target_observation": { + "kind": "publication-target-observation", + "status": "unavailable", "revision": None, + }, + }, + "checkout": { + "kind": "publication-checkout-observation", "status": "unavailable", + "worktree_id": None, "symbolic_branch": None, "head": None, + "index_observation": None, "publication_path_count": None, + "index_paths": {"predecessor": None, "candidate": None, "conflicted": None}, + "worktree_paths": {"predecessor": None, "candidate": None, "conflicted": None}, + }, + }) + def test_coverage_exclusions_require_exact_evidence_before_resolution(self): # A current accepted certificate can satisfy same-snapshot analysis. # Change an exact policy in a private proposal so this test always owns @@ -1572,6 +1633,7 @@ def test_review_composition_publishes_readiness_for_complete_analysis(self) -> N side_effect=( readiness.expected_target, readiness.expected_target, + readiness.expected_target, ), ), mock.patch.object( @@ -1626,6 +1688,7 @@ def test_review_composition_publishes_readiness_for_complete_analysis(self) -> N readiness.expected_target, readiness.expected_target, RepositoryRevision("e" * 40), + RepositoryRevision("e" * 40), ), ), mock.patch.object( @@ -1682,6 +1745,7 @@ def test_review_composition_publishes_readiness_for_complete_analysis(self) -> N readiness.expected_target, readiness.expected_target, unavailable_observation, + unavailable_observation, ), ), mock.patch.object( @@ -1853,7 +1917,9 @@ def test_review_composition_publishes_readiness_for_complete_analysis(self) -> N self.assertEqual(outcome.candidate, candidate.revision) with mock.patch.object( - self.engine._repository, "branch_revision" + self.engine._repository, + "branch_revision", + return_value=candidate.revision, ) as completed_observation: repeated_recovery = RecoverApplicationResult.from_value( facade.recover_application( @@ -1863,7 +1929,7 @@ def test_review_composition_publishes_readiness_for_complete_analysis(self) -> N } ) ) - completed_observation.assert_not_called() + completed_observation.assert_called_once_with("main", local_only=True) self.assertEqual(repeated_recovery.application, recovered.application) def test_equal_transition_is_idempotent_and_different_evidence_branches( @@ -2159,6 +2225,76 @@ def observe(source): self.assertIsNot(sources[0], sources[1]) self.assertEqual(sources[0].requested_paths, sources[1].requested_paths) + def test_authoring_evidence_diagnostics_are_bounded_and_shaped(self) -> None: + normal = { + "validation_phase": "readiness-preflight", + "evidence_reference": "evaluation/review/evidence.md", + "provider_contract": "repository-content", + "provider_contract_version": "1", + "source_kind": "repository-content", + "material_identity": "revision:" + "a" * 64, + "expected_digest": "sha256:" + "a" * 64, + "observed_digest": "sha256:" + "b" * 64, + "next_action": "refresh-review-evidence", + } + + def project(values): + return self.engine._domain_rejection(AnalysisError(AnalysisFailure( + "ANALYSIS.EVIDENCE_DIGEST_MISMATCH", "invalid", + "The selected evidence does not match.", **values, + ))).details + + self.assertEqual(project(normal), normal) + for reference in ( + "reports/review notes.md", + "reports/évidence.md", + ".evidence/review.md", + "reports/.review.md", + "reports/审查.md", + "r" * 1024, + ): + with self.subTest(reference=reference): + values = {**normal, "evidence_reference": reference} + self.assertEqual(project(values), values) + with mock.patch.object(self.engine, "_purpose", Purpose.APPLICATION): + self.assertEqual(project(values), {}) + for field in normal: + for invalid in ("a" * 4096, "line one\nline two", "", 17): + with self.subTest(field=field, invalid=repr(invalid)[:40]): + values = {**normal, field: invalid} + expected = {key: value for key, value in normal.items() if key != field} + self.assertEqual(project(values), expected) + for field, invalid in ( + ("evidence_reference", "private/../credentials.txt"), + ("evidence_reference", "/private/credentials.txt"), + ("evidence_reference", "C:/private/credentials.txt"), + ("evidence_reference", "private//credentials.txt"), + ("evidence_reference", "private/./credentials.txt"), + ("evidence_reference", "private/credentials.txt/"), + ("evidence_reference", "."), + ("evidence_reference", ".."), + ("evidence_reference", "./reports/review.md"), + ("evidence_reference", "C:private/credentials.txt"), + ("evidence_reference", "C:\\private\\credentials.txt"), + ("evidence_reference", "\\\\server\\share\\credentials.txt"), + ("evidence_reference", "private\\..\\credentials.txt"), + ("evidence_reference", "reports/review\x00.md"), + ("evidence_reference", "reports/review\t.md"), + ("evidence_reference", "reports/review\x7f.md"), + ("evidence_reference", "reports/review\x85.md"), + ("evidence_reference", "reports/review\u202e.md"), + ("evidence_reference", "r" * 1025), + ("validation_phase", "préflight"), + ("provider_contract", "repository content"), + ("next_action", ".refresh-review-evidence"), + ("provider_contract", "repository/content"), + ("provider_contract_version", "1:secret"), + ("expected_digest", "sha256:" + "z" * 64), + ("observed_digest", "sha256:" + "A" * 64), + ): + with self.subTest(field=field, invalid=invalid): + self.assertNotIn(field, project({**normal, field: invalid})) + def prepare(self, *, prior: dict[str, object] | None = None, proposed: dict[str, object] | None = None): request: dict[str, object] = { diff --git a/tools/standards_engine/tests/test_capture_handoff_transport.py b/tools/standards_engine/tests/test_capture_handoff_transport.py index faa09604..ae5001fa 100644 --- a/tools/standards_engine/tests/test_capture_handoff_transport.py +++ b/tools/standards_engine/tests/test_capture_handoff_transport.py @@ -74,7 +74,7 @@ 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'],45) + self.assertEqual(initialized['_meta']['standards-engine/runtime']['interface_version'],46) 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 69873d0e..59b32704 100644 --- a/tools/standards_engine/tests/test_consumer_publication.py +++ b/tools/standards_engine/tests/test_consumer_publication.py @@ -43,7 +43,7 @@ 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 45;',responses[1]['result']['instructions']) + self.assertIn('interface 46;',responses[1]['result']['instructions']) return responses[2] def call(self,name,arguments,purpose='authoring',error=False): diff --git a/tools/standards_engine/tests/test_coverage_publication.py b/tools/standards_engine/tests/test_coverage_publication.py index 84c2b10f..bd2ddeba 100644 --- a/tools/standards_engine/tests/test_coverage_publication.py +++ b/tools/standards_engine/tests/test_coverage_publication.py @@ -1,20 +1,44 @@ from __future__ import annotations import hashlib +import json +import os +import subprocess +import sys import tempfile import unittest from pathlib import Path from unittest import mock -from tools.standards_analysis.standards_analysis import AnalysisExecutionContext -from tools.standards_engine.standards_engine import AgentToolFacade, StandardsEngine +from tools.standards_analysis.standards_analysis import ( + AnalysisError, + AnalysisExecutionContext, + AnalysisFailure, + coverage_requirement_id, + render_engine_coverage_receipt, + validate_engine_coverage_receipt_evidence, +) +from tools.standards_metadata.standards_metadata import FrozenContentSource +from tools.standards_engine.standards_engine import ( + AgentToolFacade, + AnalysisHandle, + StandardsEngine, +) +from tools.standards_engine.standards_engine.authoring import ( + AuthoringError, + AuthoringFailure, +) from tools.standards_engine.standards_engine.tools import ( LocalAlwaysAllowAuthorizer, _contracts, ) from tools.standards_engine.tests.test_analysis import _clone_tracked_worktree -from tools.standards_snapshots.standards_snapshots import SnapshotError, SnapshotFailure -from tools.repository_git.repository_git import git_output +from tools.repository_git.repository_git import ( + RepositoryPath, + RepositoryRevision, + git_output, +) +from tools.standards_snapshots.standards_snapshots import SnapshotId class EngineAuditPublicationTest(unittest.TestCase): @@ -24,9 +48,10 @@ def test_review_verify_apply_recover_and_read_without_original_database(self): repository = root / "repository" _clone_tracked_worktree(repository) context = AnalysisExecutionContext(LocalAlwaysAllowAuthorizer(repository)) + store_path = repository / ".standards-engine" / "snapshots-v1.sqlite3" with StandardsEngine.open_repository( repository, - store_path=root / "engine.sqlite3", + store_path=store_path, execution_context=context, purpose="authoring", ) as engine: @@ -59,16 +84,41 @@ def test_review_verify_apply_recover_and_read_without_original_database(self): "test: refresh fixture verification inputs", ), ) - evidence_path = repository / "CORE-STANDARDS.md" - evidence_bytes = evidence_path.read_bytes() + snapshot = facade.create_snapshot({"kind": "create-snapshot"}) + self.assertEqual(snapshot["kind"], "create-snapshot-result", snapshot) + snapshot_id = SnapshotId(snapshot["snapshot"]["snapshot"]["id"]) + base_capture = engine._snapshots.load_content(snapshot_id) + captured_paths = {str(item.path) for item in base_capture.files} + expected_target = engine._repository.branch_revision("main") + eligible_markdown = sorted( + str(path) + for path in engine._repository.revision_paths(expected_target) + if str(path) not in captured_paths + and str(path).endswith(".md") + and str(path)[0].isalnum() + and all( + character.isascii() + and (character.isalnum() or character in "._:/-") + for character in str(path) + ) + ) + uncaptured_markdown = [] + for candidate in eligible_markdown: + evidence_bytes = engine._repository.read_file( + expected_target, RepositoryPath.parse(candidate) + ) + if len(evidence_bytes) <= 128 * 1024: + uncaptured_markdown.append(candidate) + break + self.assertTrue(uncaptured_markdown) + evidence_id = uncaptured_markdown[0] + evidence_path = repository / evidence_id reference = { - "id": "CORE-STANDARDS.md", + "id": evidence_id, "digest": "sha256:" + hashlib.sha256(evidence_bytes).hexdigest(), "provider_contract": "repository-content", "provider_contract_version": "1", } - snapshot = facade.create_snapshot({"kind": "create-snapshot"}) - self.assertEqual(snapshot["kind"], "create-snapshot-result", snapshot) policy = "workflow.commit.commit-message" proposal = facade.create_proposal( { @@ -90,7 +140,10 @@ def test_review_verify_apply_recover_and_read_without_original_database(self): }, } ) - self.assertEqual(proposal["kind"], "create-proposal-result", proposal) + self.assertEqual( + proposal["kind"], "create-proposal-result", + {"evidence_id": evidence_id, **proposal}, + ) revision = proposal["revision"] unreviewed = facade.verify_proposal( {"kind": "verify-proposal", "revision": revision} @@ -148,6 +201,226 @@ def test_review_verify_apply_recover_and_read_without_original_database(self): {"analysis": result["handle"], "submission": submission} ) self.assertEqual(result["kind"], "complete-result", result) + revision_record = engine._authoring.read_revision(revision["id"]) + projection = engine._proposal_projection(revision_record) + state = engine._load_analysis( + AnalysisHandle.from_value(result["handle"]) + ) + claim = engine._plain(state.coverage_attestations[0]) + subject = next( + selected + for selected, view in projection.compiled.coverage.views.items() + if coverage_requirement_id( + projection.compiled.coverage.requirements[selected], view + ) == claim["requirement_id"] + ) + authorization = next( + engine._plain(item) + for item in state.authorization_records + if engine._plain(item)["reference"]["id"] == claim["authorization_id"] + ) + evidence_id = claim["evidence"][0]["id"] + destination_base = { + str(item.path): item.content + for item in engine._snapshots.load_content( + revision_record.base_snapshot + ).files + } + destination_base.update(projection.captured_consumer_files) + expected_target = RepositoryRevision( + engine._snapshots.snapshot( + revision_record.base_snapshot + ).source_revision + ) + # Reusing the previous receipt must fail before it can be replaced. + receipt_path = engine._engine_coverage_receipt_path(subject) + prior_receipt = render_engine_coverage_receipt( + FrozenContentSource({**dict(projection.source.files), evidence_id: evidence_bytes}), + projection.compiled.coverage, subject, claim, authorization, + state.analysis_id, context, + phase="candidate-evidence", source_kind="repository-content", + material_identity=revision_record.revision_id, + ) + publication_files = {**dict(projection.source.files), receipt_path: prior_receipt} + publication_paths = {*projection.repository_paths, receipt_path} + publication_projection = mock.Mock( + source=FrozenContentSource(publication_files), + repository_paths=publication_paths, + captured_consumer_files=projection.captured_consumer_files, + compiled=projection.compiled, + ) + complete_evaluation = engine._evaluate(state) + for overwritten_path in ( + receipt_path, + "evaluation/standards-effectiveness/policy-coverage/attestation-sources.toml", + "evaluation/standards-effectiveness/generated/suite-inputs.json", + ): + for reference_field in ("evidence", "explicit_exclusions"): + with self.subTest(path=overwritten_path, field=reference_field): + overwrite_reference = { + **reference, + "id": overwritten_path, + "digest": "sha256:" + hashlib.sha256( + publication_files[overwritten_path] + ).hexdigest(), + } + overwritten_claim = { + **claim, reference_field: [overwrite_reference], + } + overwritten_state = state.with_decisions( + coverage_attestations=[overwritten_claim], + ) + with ( + mock.patch.object(engine, "_load_analysis", return_value=overwritten_state), + mock.patch.object(engine, "_evaluate", return_value=complete_evaluation), + mock.patch.object(engine, "_proposal_projection", return_value=publication_projection), + mock.patch.object(engine._authoring, "review_proposal") as record_readiness, + mock.patch("tools.standards_engine.standards_engine.engine.construct_authorization_record") as issue_authorization, + mock.patch("tools.standards_analysis.standards_analysis.validate_engine_coverage_receipt_evidence") as validate_evidence, + ): + rejected_overwrite = facade.review_proposal({ + "kind": "review-proposal", "analysis": result["handle"], + "decisions": [{ + "owner": owner, "decision": "accept", + "rationale": "Explicit fixture review decision.", + "evidence": [reference], + } for owner in ("consumer", "impact", "audit")], + }) + self.assertEqual( + rejected_overwrite["code"], + "COVERAGE.PUBLICATION_EVIDENCE_OVERWRITTEN", + rejected_overwrite, + ) + self.assertEqual(rejected_overwrite["details"]["validation_phase"], "readiness-preflight") + self.assertEqual(rejected_overwrite["details"]["evidence_reference"], overwritten_path) + record_readiness.assert_not_called() + issue_authorization.assert_not_called() + validate_evidence.assert_not_called() + with self.assertRaises(AnalysisError) as candidate_failure: + engine._prepare_coverage_publication( + overwritten_state.analysis_id, revision_record, + publication_projection, expected_target, destination_base, + publication_files, publication_paths, + phase="candidate-evidence", state=overwritten_state, + ) + self.assertEqual(candidate_failure.exception.failure.code, "COVERAGE.PUBLICATION_EVIDENCE_OVERWRITTEN") + self.assertEqual(candidate_failure.exception.failure.validation_phase, "candidate-evidence") + self.assertEqual(publication_files[receipt_path], prior_receipt) + self.assertNotIn(evidence_id, dict(projection.source.files)) + removed_files = dict(projection.source.files) + removed_paths = set(projection.repository_paths) + self.assertIn(evidence_id, revision_record.base_repository_paths) + self.assertNotIn(evidence_id, destination_base) + removed_files.pop(evidence_id, None) + removed_paths.remove(evidence_id) + with self.assertRaises(AnalysisError) as removed_preflight: + engine._prepare_coverage_publication( + state.analysis_id, + revision_record, + projection, + expected_target, + destination_base, + removed_files, + removed_paths, + phase="readiness-preflight", + state=state, + ) + self.assertEqual( + removed_preflight.exception.failure.code, + "COVERAGE.PUBLICATION_EVIDENCE_REMOVED", + ) + self.assertEqual( + removed_preflight.exception.failure.next_action, + "restore-reference-to-candidate", + ) + changed_destination = dict(projection.source.files) + changed_destination[evidence_id] = b"changed destination evidence\n" + with mock.patch( + "tools.standards_analysis.standards_analysis.coverage_publication.resolve_authorization" + ) as resolve_authorization: + with self.assertRaises(AnalysisError) as failed_preflight: + validate_engine_coverage_receipt_evidence( + FrozenContentSource(changed_destination), + projection.compiled.coverage, + subject, + claim, + authorization, + state.analysis_id, + phase="readiness-preflight", + source_kind="repository-content", + material_identity=revision_record.revision_id, + next_action="refresh-review-evidence", + ) + resolve_authorization.assert_not_called() + failure = failed_preflight.exception.failure + self.assertEqual(failure.code, "ANALYSIS.EVIDENCE_DIGEST_MISMATCH") + self.assertEqual(failure.validation_phase, "readiness-preflight") + self.assertEqual(failure.evidence_reference, evidence_id) + self.assertEqual(failure.expected_digest, claim["evidence"][0]["digest"]) + self.assertTrue(failure.observed_digest.startswith("sha256:")) + projected_failure = engine._domain_rejection( + failed_preflight.exception + ).as_contract() + self.assertEqual( + projected_failure["details"]["validation_phase"], + "readiness-preflight", + ) + self.assertEqual( + projected_failure["details"]["evidence_reference"], + evidence_id, + ) + self.assertEqual( + projected_failure["details"]["expected_digest"], + claim["evidence"][0]["digest"], + ) + self.assertTrue( + projected_failure["details"]["observed_digest"].startswith( + "sha256:" + ) + ) + self.assertEqual( + projected_failure["details"]["source_kind"], + "repository-content", + ) + self.assertEqual( + projected_failure["details"]["material_identity"], + revision_record.revision_id, + ) + self.assertEqual( + projected_failure["details"]["next_action"], + "refresh-review-evidence", + ) + with ( + mock.patch.object( + engine, "_preflight_proposal_coverage", + side_effect=failed_preflight.exception, + ), + mock.patch.object(engine._authoring, "review_proposal") as record_readiness, + mock.patch( + "tools.standards_engine.standards_engine.engine.construct_authorization_record" + ) as issue_review_authorization, + ): + rejected_review = facade.review_proposal( + { + "kind": "review-proposal", + "analysis": result["handle"], + "decisions": [ + { + "owner": owner, + "decision": "accept", + "rationale": "Explicit fixture review decision.", + "evidence": [reference], + } + for owner in ("consumer", "impact", "audit") + ], + } + ) + self.assertEqual( + rejected_review["code"], "ANALYSIS.EVIDENCE_DIGEST_MISMATCH", + rejected_review, + ) + record_readiness.assert_not_called() + issue_review_authorization.assert_not_called() reviewed = facade.review_proposal( { "kind": "review-proposal", @@ -183,34 +456,39 @@ def test_review_verify_apply_recover_and_read_without_original_database(self): self.assertEqual(engine._repository.branch_revision("main"), before) evidence_path.write_bytes(evidence_bytes) with mock.patch.object( - engine._authoring, - "record_applied", - side_effect=SnapshotError( - SnapshotFailure( - "unavailable", - "TEST.INTERRUPTED", - "Fixture interruption after publication.", - ) - ), + engine._repository, + "observe_publication_checkout", + side_effect=RuntimeError("fixture observation interruption"), ): applied = facade.apply_proposal(apply) self.assertEqual( - applied["kind"], "application-recovery-required-result", applied + applied["kind"], "apply-proposal-result", applied + ) + self.assertEqual(applied["publication"]["durable_state"], "applied") + self.assertEqual( + applied["publication"]["target_observation"]["status"], + "candidate", ) + self.assertEqual(applied["checkout"]["status"], "unavailable") + self.assertIsNone(applied["checkout"]["publication_path_count"]) recovered = facade.recover_application( {"kind": "recover-application", "readiness": reviewed["readiness"]} ) self.assertEqual( recovered["kind"], "recover-application-result", recovered ) - # A new store proves the repository carries the receipt and authority. + self.assertEqual(recovered["publication"]["durable_state"], "applied") + self.assertEqual( + recovered["checkout"]["status"], "needs-reconciliation" + ) + # A new database proves the repository carries the published receipt. with StandardsEngine.open_repository( repository, store_path=root / "independent.sqlite3", execution_context=context, purpose="authoring", - ) as cold: - facade = AgentToolFacade(cold, _contracts(repository)) + ) as independent: + facade = AgentToolFacade(independent, _contracts(repository)) captured = facade.create_snapshot({"kind": "create-snapshot"}) self.assertEqual(captured["kind"], "create-snapshot-result", captured) read = facade.query( @@ -231,6 +509,193 @@ def test_review_verify_apply_recover_and_read_without_original_database(self): ], [(policy, "current-attestation")], ) + # Reopening the original database proves applied status survives restart. + with StandardsEngine.open_repository( + repository, + store_path=store_path, + execution_context=context, + purpose="authoring", + ) as cold: + facade = AgentToolFacade(cold, _contracts(repository)) + status = facade.workflow_status( + {"context": reviewed["readiness"]} + ) + self.assertEqual(status["kind"], "workflow-result", status) + self.assertEqual(status["status"], "applied", status) + self.assertNotIn("outcome", status) + self.assertEqual(status["publication"]["durable_state"], "applied") + self.assertEqual(status["checkout"]["status"], "needs-reconciliation") + unavailable_outcome = AuthoringError(AuthoringFailure( + "TEST.OUTCOME_UNAVAILABLE", + "unavailable", + "The fixture cannot read the durable application outcome.", + )) + with mock.patch.object( + cold._authoring, + "application_outcome", + side_effect=unavailable_outcome, + ): + unknown_status = facade.workflow_status( + {"context": reviewed["readiness"]} + ) + self.assertEqual( + unknown_status["status"], "recovery-required", unknown_status + ) + self.assertEqual( + unknown_status["publication"]["durable_state"], + "unknown", + unknown_status, + ) + self.assertEqual( + unknown_status["checkout"]["status"], + "needs-reconciliation", + unknown_status, + ) + recovered_unknown = facade.recover_application( + { + "kind": "recover-application", + "readiness": reviewed["readiness"], + } + ) + self.assertEqual( + recovered_unknown["kind"], + "application-recovery-required-result", + recovered_unknown, + ) + self.assertEqual( + recovered_unknown["code"], + "APPLICATION.OUTCOME_OBSERVATION_UNAVAILABLE", + recovered_unknown, + ) + self.assertEqual( + recovered_unknown["publication"]["durable_state"], + "unknown", + recovered_unknown, + ) + self.assertEqual( + recovered_unknown["checkout"]["status"], + "needs-reconciliation", + recovered_unknown, + ) + project_root = Path(__file__).resolve().parents[3] + messages = ( + { + "jsonrpc": "2.0", + "id": 1, + "method": "initialize", + "params": { + "protocolVersion": "2025-11-25", + "capabilities": {}, + "clientInfo": {"name": "publication-restart", "version": "1"}, + }, + }, + {"jsonrpc": "2.0", "method": "notifications/initialized"}, + { + "jsonrpc": "2.0", + "id": 2, + "method": "tools/call", + "params": { + "name": "workflow_status", + "arguments": {"context": reviewed["readiness"]}, + }, + }, + ) + completed = subprocess.run( + [ + sys.executable, + "-P", + "-m", + "tools.standards_engine.standards_engine.mcp", + "--repo-root", + str(repository), + "--purpose", + "authoring", + ], + input="".join(json.dumps(message) + "\n" for message in messages), + text=True, + capture_output=True, + check=True, + timeout=60, + cwd=root, + env={**os.environ, "PYTHONPATH": str(project_root)}, + ) + responses = [ + json.loads(line) for line in completed.stdout.splitlines() + ] + status_response = next(row for row in responses if row.get("id") == 2) + self.assertNotIn("error", status_response, status_response) + restarted_status = status_response["result"]["structuredContent"] + self.assertEqual(restarted_status["kind"], "workflow-result") + self.assertEqual(restarted_status["status"], "applied") + self.assertEqual( + restarted_status["publication"]["durable_state"], "applied" + ) + self.assertEqual( + restarted_status["checkout"]["status"], "needs-reconciliation" + ) + with StandardsEngine.open_repository( + repository, durable=False, purpose="authoring" + ) as authoring_engine: + legacy_failure = AnalysisError(AnalysisFailure( + "ANALYSIS.EVIDENCE_UNAVAILABLE", + "invalid", + "The evidence source is unavailable.", + path="evaluation/standards-effectiveness/attestation-sources.toml", + field="engine_sources", + observed="legacy-source", + )) + legacy_details = authoring_engine._domain_rejection( + legacy_failure + ).details + self.assertEqual( + legacy_details, + { + "path": "evaluation/standards-effectiveness/attestation-sources.toml", + "field": "engine_sources", + "observed": "legacy-source", + }, + ) + unsafe_failure = AnalysisError(AnalysisFailure( + "ANALYSIS.EVIDENCE_UNAVAILABLE", + "invalid", + "The evidence source is unavailable.", + path="/private/credentials.txt", + field="engine_sources", + observed="line one\nline two", + )) + self.assertEqual( + authoring_engine._domain_rejection(unsafe_failure).details, + {"field": "engine_sources"}, + ) + traversal_failure = AnalysisError(AnalysisFailure( + "ANALYSIS.EVIDENCE_UNAVAILABLE", + "invalid", + "The evidence source is unavailable.", + path="private\\..\\credentials.txt", + field="engine_sources", + observed="safe-observation", + )) + self.assertEqual( + authoring_engine._domain_rejection(traversal_failure).details, + {"field": "engine_sources", "observed": "safe-observation"}, + ) + with StandardsEngine.open_repository( + repository, durable=False, purpose="application" + ) as application_engine: + private_failure = AnalysisError(AnalysisFailure( + "ANALYSIS.EVIDENCE_DIGEST_MISMATCH", + "invalid", + "Resolved evidence bytes do not match the declared digest.", + validation_phase="readiness-preflight", + evidence_reference="private/internal/evidence.md", + expected_digest="sha256:" + "a" * 64, + observed_digest="sha256:" + "b" * 64, + path="/private/internal/evidence.md", + field="engine_sources", + observed="private-value", + )) + redacted = application_engine._domain_rejection(private_failure) + self.assertEqual(redacted.details, {}) if __name__ == "__main__": diff --git a/tools/standards_engine/tests/test_registration_contract.py b/tools/standards_engine/tests/test_registration_contract.py index 92631881..d67d7bd3 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"], 7) + self.assertEqual(self.interface["result_projection_version"], 8) 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_routing_fact_transport.py b/tools/standards_engine/tests/test_routing_fact_transport.py index 0cf4c9c7..fa51509a 100644 --- a/tools/standards_engine/tests/test_routing_fact_transport.py +++ b/tools/standards_engine/tests/test_routing_fact_transport.py @@ -210,7 +210,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'],45) + self.assertEqual(page['interface_version'],46) 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 97e7b909..d2a41e93 100644 --- a/tools/standards_engine/tests/test_runtime_identity.py +++ b/tools/standards_engine/tests/test_runtime_identity.py @@ -32,7 +32,7 @@ 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'], 45) + self.assertEqual(value['interface_version'], 46) 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 4619a932..a907a30b 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'], 45) + self.assertEqual(value['interface_version'], 46) 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 eb1177df..581ecbf5 100644 --- a/tools/standards_engine/tests/test_supporting_workflow.py +++ b/tools/standards_engine/tests/test_supporting_workflow.py @@ -12,6 +12,7 @@ from tools.standards_metadata.standards_metadata import load_canonical_standards_corpus RULE = "topic.purpose-fixture" +UNEXPOSED = "topic.purpose-fixture-unexposed" REFERENCE = "reference.testing.purpose-fixture" REASON = "provenance.purpose-fixture" PRIVATE = "PRIVATE_DECISION_RECORD_506187" @@ -77,8 +78,6 @@ def publish(self, proposed): def test_coordinated_publication_and_provenance_only_revision(self): snapshot = self.author.create_snapshot({"kind": "create-snapshot"})["snapshot"]["snapshot"] - empty = self.app.read({"snapshot": snapshot, "target": "topic.security"}) - self.assertEqual(empty["code"], "APPLICATION.CONTENT_UNAVAILABLE", empty) aids = [] for target in ("prompts/planning.md", "templates/PLAN-TEMPLATE.md"): aid = self.author.read({"snapshot": snapshot, "target": target}) @@ -87,7 +86,7 @@ def test_coordinated_publication_and_provenance_only_revision(self): record = {"id": REASON, "subject": RULE, "origin": "current-justification", "rationale": PRIVATE, "evidence": [evidence(self.root)]} edits = [{"kind": "approve-application-content", "target": RULE}, {"kind": "put-provenance", "record": record}, - standard(REFERENCE, reference=True), standard(RULE), + standard(REFERENCE, reference=True), standard(RULE), standard(UNEXPOSED), {"kind": "approve-application-content", "target": REFERENCE}] for aid in aids: lines = aid["content"].splitlines() @@ -110,6 +109,12 @@ def test_coordinated_publication_and_provenance_only_revision(self): # Reads in this interval observe the same accepted publication. published_snapshot = first["snapshot"] self.assertNotEqual(published_snapshot, snapshot) + # Own the negative fixture independently of application exposure in the + # 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") for aid in aids: exposed = self.app.read({"snapshot": published_snapshot, "target": aid["canonical_id"]})