Application approval is a review label, not a delivery gate. Every registered
standard and registered operational aid (prompt, template or documentation) that
an application call selects or names is delivered. route, read, read_many,
related, relationship_groups, routing_facts, inspect, native query and
authoring preview_application no longer depend on the approval state of the
Router, Core, the target or its prerequisites. Editing Core or the Router changes
their labels; it does not take the application interface offline.
Each application read result (single, grouped, routed content item or candidate
preview) and each application reading_plan entry carries review_state:
review_state |
Authoring application_exposure |
Meaning |
|---|---|---|
current |
current |
This exact material was approved for application use. |
changed-since-review |
needs-review |
The material changed after its approval. |
not-reviewed |
unreviewed |
The material has never been approved. |
A scoped policy read carries the label of its containing module. A label reports
the item's own state; prerequisites carry their own labels where they are
delivered. Labels describe editorial review of the wording, not whether guidance
applies. The approval manifest, its Engine-derived bindings,
approve-application-content, withdraw-application-content, the authoring
application_exposure values and the review workflow are unchanged.
The application relationship graph contains every registered material and its
registered policy units, restricted to the standards-requires,
standards-specializes, standards-dependencies, policy-impact and semantic
groups. Decision provenance, the decision-provenance group and unregistered
consumers such as fixtures and implementation artifacts stay outside it; they can
neither be read nor connect a traversal.
APPLICATION.CONTENT_UNAVAILABLE is removed; no path reports that guidance awaits
publication. Rejections name what the caller can correct:
| Code | Outcome | Cause |
|---|---|---|
APPLICATION.UNKNOWN_TARGET |
invalid |
The identity or handle is not registered application material. Use an ID exactly as a route, read or related result gave it. |
APPLICATION.UNKNOWN_GROUP |
invalid |
Unchanged for related; candidate previews now return it too. |
APPLICATION.TRAVERSAL_NOT_PERMITTED |
invalid |
The selected group does not permit that direction or transitive traversal. |
Misspelt, unknown, provenance and unregistered-consumer identities receive the
same APPLICATION.UNKNOWN_TARGET result, so the code does not reveal whether a
private record exists. Any other graph failure is
APPLICATION.INTERNAL_UNAVAILABLE. Candidate previews return the same codes and
messages bound to their revision.
Application route content pages are sized for inline display by the client. The
page budget defaults to 40 KiB (40,960 bytes) of the result's one default JSON
serialization, which is the MCP text copy; the duplicate structured copy and
protocol framing are outside it. An application server accepts
--route-page-bytes N from 8,192 to 2,097,152; the option is a launch error for
authoring. Byte pressure ends a page before the next whole read, and a page always
keeps its first whole read: a module larger than the budget is returned alone,
never clipped or rejected. Only a result above the 2 MiB transport bound returns
APPLICATION.RESULT_LIMIT. Follow content.next unchanged. Authoring route
content, read_many in both purposes and selection-only routes keep their
existing bounds.
Application initialize instructions and tool descriptions state the normal
sequence in plain language. Application agents learn the same sequence from the
coding-standards skill.
Interface 49 and result projection 9 version these result shapes. Request contract 6 and snapshot, Analysis, handle and store versions are unchanged, and no stored state is migrated. Restart the MCP process and refresh the client catalog. Sections below that describe an approval gate record earlier editions.
Authoring maintain_evidence accepts optional
plan.retire_engine_certificates selections with subject, requirement_id
and a nonempty rationale. Each exact pair must identify one registered
Engine-issued receipt. Unknown, duplicate or ambiguous selections reject the
whole maintenance operation. The existing exact-revision, evidence,
authorization, preview, candidate verification and guarded-write requirements
continue to apply.
Retirement removes the selected receipts from the working tree and source registry. Git history preserves the original records. It changes no normative policy, registered policy subject, semantic consumer relationship, application exposure or unselected receipt, and issues no replacement certificate. This supports explicitly retiring a proof before changing a file that proof cites even when the policy requirement itself has not changed. Evidence hashes remain strict; no inferred retirement or digest substitution is introduced.
Refresh generated contracts and reconnect after deployment. Existing requests without retirement selections, workflow/store identities and purpose boundaries retain their contracts.
This is implementation and deployment documentation. It describes the Engine mechanism; it does not classify the real standards as positively written or ready for application use.
Engine/facade construction and local transport launch require an explicit
application or authoring purpose. Purpose remains fixed for that interface.
Tool arguments, detail options and handles select material, not purpose.
Authorization remains the existing independent injected contract. The local
facade is an owner-operated always-allow authorization adapter for admitted
authoring operations; this release does not supply a multi-user access service.
Application operations are route, read, read_many, related, routing_facts, query
and inspect. The focused MCP catalog omits native query; --advanced can
expose it within the same purpose. Authoring retains the complete existing
workflow. Canonical interface operation variants own each purpose's input and
result definitions; MCP and CLI project only their reachable schema closure.
The public application boundary constructs dedicated result values from registered domain material. Full detail remains within that boundary. Both MCP result encodings carry the same value. Unknown/private identities and malformed requests receive bounded application outcomes. Detailed operational failures stay in host-private diagnostics, which the host must keep outside an application agent's independently readable filesystem.
New snapshots capture the configured local accepted branch, main, rather than
the checked-out branch. This prevents an unpublished branch from becoming
application-visible through automatic snapshot capture. Proposal reads use
exact proposal revision authority and are authoring-only.
The two support manifests are mandatory captured inputs:
evaluation/standards-effectiveness/application-content.tomlevaluation/standards-effectiveness/decision-provenance.toml
Both are empty in this code delivery. Existing normative and reference bytes
remain unchanged and authoring-readable after the code candidate is integrated
into accepted main. Material without an approval is delivered with the
not-reviewed label (before interface 49 it was withheld). An empty manifest is
intentional bootstrap state, not an inference that legacy prose was reviewed.
A supported snapshot contains its exact support records, exposure decisions, Router inputs and material. Reopening uses those captured bytes. Later exposure withdrawal affects newly captured accepted authority, while a retained historical snapshot keeps its original decision. This mechanism does not retroactively erase context or revoke bytes already delivered to an agent.
Old captures lacking the support contract return
SUPPORT.UNSUPPORTED_CAPTURE (bounded as APPLICATION.UNSUPPORTED_CAPTURE in
application output). Old Analysis records are unsupported under Analysis 7.
Existing SQLite storage mechanics and Snapshot handle version 5 remain in use;
there is no automatic deletion, conversion, alternate old reader or dual write.
Capture owns one bounded exact-revision Git read session for its recorded first pass, closes that session, and compiles the frozen replay independently. Both the requested-path closure and semantic signature still have to agree. The selected accepted-main revision stays fixed throughout that capture.
Analysis preparation and resolution borrow verified immutable inputs for the current operation. Identical snapshot roles share one material value; distinct roots keep independent lifecycle and content observations. Focused proposal creation, revision, analysis and resolution pass one explicit proposal-material scope through preflight, prospective validation and native analysis. It retains one verified base and only the most recent exact projection; changing revisions replaces that projection. Authoring receives its pure preparation dependency per invocation while retaining ownership of durable roots and conditional writes.
Each material access checks current snapshot lifecycle. Stored revisions, heads, authorization and pre-/post-submission decisions retain their independent checks. Changed candidates take the complete compiler path; capture's two passes remain independent. Scope cleanup releases retained references on success or failure. The scope contains no provider outcomes or evaluation results. Nested public re-entry constructs its own scope, and public request shapes remain unchanged.
Each subsequent operation loads and verifies its own captured bytes. Publication verification, target compare-and-swap and recovery obtain fresh observations; no operation-local material crosses those barriers as permission or readiness. One MCP server process has one facade and Engine, opened by its first store-backed call and described under One Engine per server process; the SQLite lifetime remains per call. The Engine keeps a bounded cache of pure snapshot compilation as described below. Operation-local workflow state, evaluations and permissions remain per-call. Exact draft projection retention is described separately below.
The MCP server compiles its installed API interface once. Discovery and invocation consume that same contract, and every request still uses the complete generated decoder and current purpose-qualified result checks. The interface describes the installed implementation, not the accepted standards revision. Replacing Engine code or its API schema requires a controlled process restart. Ordinary standards publication keeps the installed interface valid. Standalone facades prepare their own interface unless their trusted owner supplies an already prepared one.
Preparing the interface does not repeat Draft 2020-12 metaschema validation for the schema the contract generator already validated. The generated contract records that schema's digest; a schema file with another digest is validated in full, as described under Metaschema validation. Every other interface check runs at each start.
Every Engine has a repository/purpose-scoped compilation cache with a two-entry and 32 MiB accounted-retention limit shared by snapshot and draft projection entries. An Engine keeps its own until it closes, unless its owner lends one that outlives it; the one Engine of an MCP process keeps its own for that process, and a CLI invocation's Engine for that invocation. Snapshot keys contain the exact verified captured paths, bytes and source revision, plus the installed compiler function. Python dictionary equality distinguishes hash collisions. Each new MCP call opens its store, checking its application, version and exact schema, and each operation checks snapshot lifecycle and verifies complete content identity before lookup. Missing, quarantined, purged or replaced storage, and content that no longer matches its identity, therefore remain observable. The store's complete SQLite integrity/foreign-key audit is not repeated by every operation: a process runs it on its first open of a store file, as described under Snapshot admission. Equal verified inputs may share pure compilation even when obtained from distinct store roots; store-specific handles, access checks and result envelopes remain fresh. No store facts enter the cache.
Successful full compilation is eligible for retention. The cache has no negative entries, response objects, live authorization/provider outcomes, mutable proposal heads, readiness or publication outcomes. Snapshot-bound attestations and exposure declarations remain part of that historical material; they grant no new access. Eviction, oversized inputs and entries whose retained size cannot be established use the normal verified computation. The accounting walk charges reachable Python data once per entry, includes captured bytes and mapping tables, and conservatively charges inter-entry sharing separately. It materializes pathlib value caches before accounting. Imported implementation code and bounded LRU bookkeeping are separate from the per-entry budget. The budget is not a process-RSS or transient-working-memory limit.
Capture always resolves accepted main and runs both independent live/frozen compiler passes and closure checks. Neither pass consults the cache. A later explicit read may reuse only a compilation of its own fully verified capture. Advancing main affects new captures; historical snapshots preserve their captured material. Publication candidate verification and recovery keep their existing fresh observations. Each new process starts empty and reconstructs correctly.
The transport retains serial dispatch and opens and closes a SQLite connection for each call. Pure cached structures are read-only through their owned interfaces; each response and continuation is newly constructed. The cache is not a thread-safety guarantee for concurrent use of one Engine. Independent server processes retain separate fixed-purpose resources. Stream EOF or failure releases the server-owned interface and catalog and closes the Engine with its store and cache; closing an Engine that borrowed a cache closes its store without releasing the owner's cache.
An MCP server process opens its facade and Engine with the first tool call that
needs a store, uses them for every later call, and closes them when the server
closes. runtime_info, describe_input and describe_output need no Engine
and open none. A CLI invocation is one process with one Engine for its single
operation, as before.
The store connection is not part of that lifetime. Each call opens one and closes it when the call ends, so between calls the process holds no store connection, no SQLite lock and no open store file, journal or write-ahead log, and a call may come from any thread. What a call observes is what it observed when every call opened its own Engine:
- The store is opened for every call. Before a call the server asks the
Engine to readmit, which opens a new connection and runs the statements a new
open of that existing file runs: application, version and exact schema, the
required SQLite profile, a version 1 migration with all of its audits, and the
maintenance probe with any due purge. A failure there is the same private
failure as a failed open:
isErrorwith the generic text, the diagnostic on stderr, and no structured result. Only the complete integrity audit that the process already ran for that file is not repeated, as before. - Another process's work is visible to the next call. A new connection has read nothing, so committed snapshots, proposals, quarantine and purge by another server or a CLI call, a store migrated or altered in place, and a store file overwritten in place are all read as they are on disk.
- A replaced or missing store file opens a new Engine. Before opening the connection the Engine compares the repository root and store path it was opened with against what they resolve to now, and the store path against the file it opened. When either resolves elsewhere, or the store path names another file or none, the server closes the Engine and opens a new one: that open audits a file the process has not audited, creates a missing store, and refuses a path that is not a regular file, exactly as an open always has. The process also forgets its audit record of the file that was replaced. The compilation cache belongs to the Engine, so nothing compiled from the old store's content is carried to the new one except by verifying the new store's bytes again.
- No operation state is kept. Operation material (
ProposalMaterials, its decoded revision, base and projection) and Git read sessions and candidates are created inside one operation and released when it ends, on success or failure. Nothing an operation computes is attached to the facade, the Engine or the snapshot module; what stays is the pure compilation cache. A store transaction is committed or rolled back by the store method that began it, and closing the call's connection rolls back one that was not ended. - An Engine is not used after a failure nobody classified. A typed
rejection is an ordinary outcome and keeps the Engine. An exception that
reaches the transport, an interruption, and an unclassified failure that an
application operation reports as its bounded
APPLICATION.INTERNAL_UNAVAILABLErejection all close the Engine and its cache before the result is returned. The next call opens a new Engine. Results and diagnostics of the failed call are unchanged, and nothing is retried.
Draft reads, analysis, status, creation/revision preparation and focused resolution can retain the pure projection of one exact immutable proposal revision. They use the existing compilation-cache owner and its shared two-entry / 32 MiB budget. One base plus one current draft fits the measured workload; older entries can be evicted normally. The runtime adds no persistent cache or new wire format.
Each new public call reads the actual stored revision/root and fully validates its original captured base before lookup. The key binds exact base bytes/paths, the existing canonical representation of the complete revision (original snapshot, repository membership, proposal identity, ordinal and all change sets), and the installed replay recipe. Static compiler implementations qualify; custom stateful adapters execute cold. The compiler's original accepted base remains the semantic comparison authority. On an exact-revision miss, an eligible verified prefix may supply successor construction as described below. Without one, the entire program replays with all normal checks.
Retained semantic-intent maps are private copies. Each operation receives fresh intent maps and result envelopes while sharing read-only sources and compiled structures. Status and pre-/post-submission evaluations still run. Authorization, evidence, snapshot lifecycle, proposal-head observations and conditional writes remain current. A prospective projection retained before a failed publication is only reusable computation: its handle still requires a real stored revision/root.
Review, candidate verification, application and recovery retain their existing fresh replay paths. New snapshot capture retains both independent compiler passes. Main advancement affects new captures, never the base of an existing draft. Old explicit revisions retain historical meaning and can have live stale status. Stored content that fails validation, quarantine, purge or missing/replaced stores reject before projection reuse. Server restart reconstructs cold and repeats the store's complete SQLite audit; close releases both entry kinds.
The logical compiler can copy a previously verified projection and execute only its appended change sets. Eligibility binds the exact original frozen base, original snapshot identity, complete base repository membership, canonical change-set prefix, installed compiler identity, projected bytes and projected membership. The compiler snapshots the program representation into immutable inputs, then issues continuation provenance only after successful final compilation and cumulative analysis. Caller-owned edit mappings and semantic-intent maps cannot rewrite that provenance.
The operation-local owner may offer its last projection. The existing bounded cache may offer the immediate predecessor of the same proposal on an exact successor miss. Both feed the same compiler-owned eligibility check; neither adds a cache, persistent checkpoint, store format or compatibility mode. An incompatible or absent prefix selects complete replay, including after eviction or restart. A cold focused workflow may first reconstruct its predecessor during preflight and then use that newly verified material for the suffix in the same operation; it still pays for the first reconstruction.
Successors use a new file table with immutable byte values. All edit semantics, manifest membership calculations and cumulative analysis retain the original accepted base. Final authority compilation, semantic successor validation and complete-program policy/module analysis still run. This is a computation reuse boundary, not a new accepted baseline or authorization/publication proof. The independent review, candidate-verification, application and recovery paths above continue to select full replay.
The deciding structural claim is suffix-only edit execution and manifest regeneration for a simple append with an eligible predecessor. Canonical program comparison, final compilation, retention accounting and complete analysis remain whole-material work. Representative successor-admission latency qualification is tracked in the incremental successor report; it is distinct from repeated-read latency or focused-test duration.
read_many takes one explicit snapshot and 1–32 ordered items. Each item has a
target and optional detail; authoring also permits the single-read coverage
and routing options. Exact duplicate requests are invalid. Reuse the snapshot
returned by routing or a single read, and select only the needed guidance.
The result contains the original snapshot and ordered single-read results. One complete durable content/identity validation supplies the whole operation; current snapshot lifecycle is checked before every item and before return. Purpose, review-label and item-option handling use the ordinary read projection. Any failed item or lifecycle observation rejects the entire set. No item content is returned on failure. A new independent call verifies durable content again. This is a new explicit operation, not a change to single reads.
The complete domain result is bounded to 2 MiB in the transport's default JSON
encoding (ASCII escaping and default separators); protocol framing, alternate
pretty-printing and MCP's duplicate structured/text encodings are outside that
payload bound. A larger set returns READ_MANY.RESULT_LIMIT in authoring or
APPLICATION.RESULT_LIMIT in application. Select fewer items or smaller policy
scopes; the Engine neither truncates material nor substitutes partial success.
read_many uses the named operation through MCP, the reference CLI and the
native facade; it is not a new request variant inside query or query_proposal.
Restart clients/servers after the interface update to discover the new operation.
A declaration identifies an entire canonical module or registered operational prompt/template and the Engine-derived exact reviewed binding. Scoped policy reads inherit the containing module's qualification. Whole-module material includes headings, tables, links, metadata and registered policy declarations; Router material additionally binds the actual routing facts, rules and bases. Operational aids bind their source content and registered policy-owner facts.
The derived states are unreviewed, current and needs-review. Content changes
preserve the old declaration as stale until explicit renewed approval or
withdrawal. The application view delivers material in every state and reports the
state as its review_state label; see
labelled application delivery.
Unknown applicability remains a request for facts.
Supplementary relationships remain selective. A prompt's policy-impact
association does not acquire Requires semantics. The application graph view
contains its permitted endpoints (registered materials and their policy units)
before traversal, so hidden intermediary nodes cannot connect otherwise
disconnected visible material. Whole-module discovery
includes relationships declared by its registered policy units.
Approval is an editorial decision. The runtime checks the declaration and binding and reports the result as a label; it does not classify sentiment or prove prose quality. No positivity model or lexical prohibition list is part of the runtime.
Each record owns one descriptive subject association. The standards-aware graph
source derives the justified-by edge in decision-provenance; no second
editable copy of that association exists. Supersession links form an acyclic
history. Retired records remain readable by authoring callers and can retain
historical subjects, while active records require a current canonical subject.
These relationships have no automatic normative-dependency or impact meaning.
A record includes its canonical identity and subject, Engine-derived subject binding, origin, rationale, and the existing four-field evidence representation. Optional sections hold assumptions, limits, alternatives, reconsideration and supersession. Historical-origin claims require evidence references. An explicitly unrecorded origin permits an empty account instead of fabricated history.
A record can become needs-review after its subject changes. Updating rationale
alone changes that support record and its localized review, not unchanged
normative semantic revisions or every unrelated consumer certificate.
All edits travel in the existing StandardsChangeSet through propose/revise,
analysis, explicit review and atomic local apply. Exact fields are supplied by
the current generated schema; this table is a navigation aid, not a validator.
| Task | Edit or read |
|---|---|
| Read a complete owner or scoped policy | Authoring read; inspect metadata/relationships as needed |
| Revise module body and metadata | revise-standard |
| Relocate/rescope registered headings in a full rewrite | revise-standard.scope_updates, with all existing scope identities and explicit semantics |
| Register a selected scope within an existing owner | register-policy-unit, using the existing canonical module ID and a new policy declaration |
| Revise one policy scope | revise-policy-unit |
| Create/revise a supplementary reference | create-standard / revise-standard with the existing reference role |
| Inspect an existing registered prompt/template | Authoring read returns its opaque target handle |
| Revise a registered prompt/template | revise-operational-artifact using that handle, title and body |
| Record or replace decision reasoning | put-provenance |
| Retain a reasoning record as historical | retire-provenance |
| Approve exact final application material | approve-application-content |
| Withdraw an exposure decision | withdraw-application-content |
| Change normative prerequisites/specialization | replace-standard-relationships |
| Change other actual consumer relationships | Existing put-policy-relationship / remove-policy-relationship |
| Change Router decisions or presentation | Existing routing rule/fact edits |
| Inspect a draft | Authoring query_proposal against its exact revision |
| Publish the reviewed candidate | Existing explicit review, then apply; follow recover on recovery-required |
Existing-owner registration supports modules with zero or more registered policies. It preserves existing prose and declarations, and can follow a whole-module rewrite in the same candidate. New scopes are selected explicitly; module and existing-policy edits precede the registration group, then consumer relationships resolve against the completed registry. Existing canonical scope, identity and lifecycle validation applies. Registration alone issues no coverage certificate. The same logical program is replayed after restart or through an eligible incremental successor; storage and handle editions are unchanged.
The registration qualification plan tracks the current source correction and its outstanding full-checkout/MCP acceptance. Interface 33 availability does not by itself certify that qualification.
The Engine resolves unordered same-change-set references against the final candidate. It stages retirement and withdrawal privately before dependent owner changes, computes approval/provenance bindings after material edits, and validates the complete result before admitting the proposal revision. Contradictory edits and dangling active subjects reject without publication. Registered operational aid handles identify only captured prompt/template registrations; requests do not authorize arbitrary repository-file or source-code writes.
Meaning-preserving rewrites may change structural text while keeping the policy's
semantic revision through an explicit preserve decision. Substantive changes
select the next revision. The candidate contains the exact intended semantic
revision before review; preservation/next-revision proposals are analyzed against
those same bytes. The Engine does not rewrite semantic versions after review.
Current Engine package/transport implementation: 0.2.0. Engine interface: 36. Analysis request: 6; result/state and Analysis handles: 7. The semantic-revision interpretation change belongs to Analysis 7. Unchanged Snapshot, proposal, readiness, application and generic identity/storage contracts keep their existing independent versions. Updating one implementation does not couple all version domains.
Before replacing an installed Engine, inspect active proposals, readiness and recovery-required work through its current authoring interface. A replacement supporting the same retained record formats can resume them through its documented recovery path; interface 35 preserves those formats. When a retained format is unsupported, complete its recovery with the owning implementation or preserve its exact store under an explicit operator disposition. Keep store bytes and Git history. Install current code/schemas and reconnect with purpose-selected launch configuration. A fresh store does not carry an admitted application and is not a recovery procedure. Store selection never converts old proposal records.
For pre-merge qualification, use a disposable clone whose local main identifies
the exact candidate. Avoid retargeting the user's real accepted branch merely to
make a test pass. The code is integrated before the content guide is executed.
The host controls access to the checkout, database and private logs. A caller with independent access to those files can read them outside the Engine. Use a fresh application context after standards authoring; changing an interface does not remove information already in a model conversation.
Focused tests cover qualification, staleness, purpose/handle escalation, hidden intermediaries, schema closure, scope discovery and bounded diagnostics. Separate process tests exercise CLI/MCP output and real SQLite reopening. The supporting workflow test uses real proposal/review/Git publication with synthetic content; its fixture decisions are not endorsements of real standards.
Run affected package tests and the structural checkpoint separately. The optional
tests/mcp_workflow_client.py additionally exercises the official SDK, both
purposes and interrupted-publication recovery using a separately supplied client
environment. The configured Codex adapter test names the authoring registration
with --server. Pinned-platform/client acceptance and independent review are
reported separately from supporting tests in another Python environment.
Use register-consumer inside propose or revise to declare an existing
tracked consumer. The Engine captures its original proposal-base bytes before
admission, retaining them in the immutable logical edit. Replay uses those bytes,
not the working tree or a later accepted revision. Registration, newly created
policy scopes and their consumer relationships can share one candidate. An
explicit relationship uses the registered canonical consumer ID. Registration
neither claims complete coverage nor creates a review certificate.
The content editor supports registered Markdown documentation as well as prompts and templates. Hidden directories have the same repository containment and tracked-file requirements. Fixture and implementation consumers remain read-only through this editor. Original file bytes supply publication's baseline; an unchanged registered source is not rewritten. Fixture bytes, unrelated policy identities and prior proposal records remain intact.
An authoring caller uses preview_application with the exact draft revision and
one application read, route or related request. Candidate results carry that
revision, without published-snapshot or snapshot-child handles. Their
continuations remain candidate previews. The same application view supplies
delivery, review labels and graph filtering. An unregistered target is a
candidate-application rejection. Normal application sessions retain their
published-only operation set.
maintain_evidence remains accepted-repository maintenance, not draft mutation.
Use logical registration for draft-only scopes. After installing this change,
restart the actual MCP server and reconnect the client; initialization reports
the current interface edition and configured purpose. Existing workflow-response verbosity
and hot catalog replacement are not changed by this capability.
Use recover with the original readiness context after an interrupted or failed
publication. Its default observe action reads the exact selected application;
it may record a durable applied outcome when the target is already the candidate,
but it performs no Git write. The native equivalent is recover_application.
When the target is still the expected revision, an authorized operator can select
action: "complete-publication". This action reconstructs from the original
captured proposal and reviewed coverage, requires the exact already-admitted
commit ID, reruns complete verification, checks current readiness and both recovery
and application permission, and makes one expected-target publication attempt.
It keeps the existing application selection. Changed candidate content, stale
readiness, inaccessible evidence, denied authority and a competing target stay
explicitly unresolved. A target already at the candidate is reconciled without
another write. A failed outcome write after Git success is completed by the next
observation. Focused and native repeated recovery return the applied result.
An unchanged target does not establish that no prior publication occurred. Explicit completion authorizes re-establishing the candidate at that target; it is not a historical exactly-once claim. The Engine never removes a lock, changes permissions, resets the store, forces the branch, or substitutes a newer draft.
The implementation process needs a Git-writable authorized host for the same
repository and store. Install Engine source without moving the real accepted ref
merely for installation: an admitted application is still bound to its original
expected target. Restart the server process and reconnect before reading the
interface-35 recovery schema. Install the current code and interface schemas
together in the implementation checkout, while leaving its accepted main at
the admitted expected revision. The facade loads interface schemas from
--repo-root; selecting a different Python module path alone does not update
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 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.
Router selection is declared by unfenced top-level two-column pipe tables. Canonical normative-module links in the destination cell identify selected modules. Header text, section headings and surrounding prose are presentation; a historical example heading is not an executable delimiter. Reference-module links are optional help. Code fences, indented code, HTML comments and non-table prose do not declare selections.
The existing Analysis routing owner parses these exact rows for the Router
loader, read(include_routing) and logical route edits. The explicit executable
facts/rules still own applicability, and their target agreement is verified.
Edits preserve all text outside selected rows, and new rows join an existing
normative selection table. Ambiguous duplicate rows reject an individual edit.
Unsupported link paths or missing canonical targets remain explicit failures.
No Router body, policy identity or routing fact is automatically migrated.
Focused workflow results default to detail: compact. A pending or complete
Analysis is represented by its exact handle, truthful work counts and a
workflow_details link; publication, readiness, recovery and errors retain
relevant fields. detail: full selects complete diagnostic output. Native
analysis operations retain their full result contract.
resolve_many is authoring-only. Supply one exact current proposal Analysis
context and 1–128 explicitly authored submissions (up to 256 KiB of JSON
submission material). All work handles bind that original context. Required
work newly revealed by a decision is retrieved in the next round rather than
invented as a handle on the old analysis. Duplicate targets and foreign work
reject before authorization.
Each item uses the ordinary single-decision validator with current evidence and authority. The staged successor is evaluated before the next item. Only the final Analysis aggregate is published, conditionally on the proposal head still matching. A rejected batch records none of its intermediate Analysis states. External authority/provider observations are not part of a global transaction. No review, readiness, apply or implicit Git write is included in decision batching.
Example flow (obtain actual field values and handles from current results):
workflow_details({analysis: context, section: "pending_obligations", limit: 8})
resolve_many({context: context, submissions: [explicit_decision_1, explicit_decision_2]})
Each pending_obligations item contains the complete obligation plus its
submission work handle. Coverage work is a coverage-requirement handle;
consumer/impact work is an obligation handle. fact_requirements supplies the
actual fact definition and work. Preserve every decision's fingerprint, evidence,
rationale and authority requirements. Registration is distinct from coverage.
Other detail sections expose all obligations, historical coverage certificates, recorded dispositions/facts, reading plan and changed policy units. Compact requests select at most 16 whole records (default 8) and 64 KiB of result JSON, including the continuation. Byte pressure returns a shorter contiguous page. The byte accounting uses default JSON encoding with ASCII escaping and default separators; MCP envelopes, text/structured duplication and client pretty-printing are outside this bound. Observation identity is independent of page size.
When the first requested record alone is oversized, WORKFLOW.RESULT_LIMIT
returns no partial record and supplies a typed workflow_details continuation
under next_operations. The continuation's request selects detail: full,
that exact Analysis/section/offset/observation, and limit: 1. Choose it explicitly
only when the client can receive the complete payload: full detail is a
size-unbounded diagnostic response for one record, not an automatic workaround
for the compact limit. Full calls accept limit omitted or 1. Their next request
resumes ordinary compact paging. No rationale, evidence, or item is truncated,
no record is skipped, and no new blob store or paging session is created.
Existing full workflow results do not expose every independently readable detail section. Full detail at this same operation therefore works for both snapshot- and proposal-backed Analysis without selecting a different context or weakening its purpose/lifecycle checks. It reads the same historical evaluation as compact paging, including after process replacement.
Follow the exact next arguments. A nonzero offset requires the returned
observation digest. It binds the exact analysis, section and complete observed
items, preventing accidental mixing of contexts or sections. Historical details
remain snapshot-bound; decision and publication owners perform live evidence
validation. Lifecycle failures remain explicit. Pages are observations, not approvals or
new mutable workflow records. Explicit full analysis remains available.
runtime_info is available to either purpose without opening Git or the
standards store. MCP initialization, tool listings, tool results and unknown-tool
errors expose the same opaque instance/interface/catalog metadata. The operation
also compares a supplied expected_catalog digest and observes on-disk runtime
installation state.
Runtime identity binds startup-selected code/package and interface inputs. It
excludes standards text, Git refs, authoring databases and user paths. It assumes
a coherent installation before startup, not concurrent replacement during import.
A disk change produces restart-required; unreadable inputs produce unavailable.
A matching installation with a differing client catalog requests refresh-tools.
The server cannot inspect or clear the client's private cache.
After replacing implementation files, stop the old process, install coherently,
start the new process, reconnect and inspect runtime_info/tools/list before
mutations. Check the new instance ID as well as interface 37 and the catalog digest.
listChanged remains false: no hot reload is implemented. Content publication
alone does not require an implementation restart. Standalone native facade
catalog identity describes its native operation contract; compare catalogs within
the same transport/purpose. At interface 36 the reference CLI used the focused MCP catalog identity; interface 40 aligns it with its full listed operation surface.
Interface 36 changes the focused result contract and adds three operations. It preserves Analysis 7, original Snapshot/SQLite representations, readiness, exact candidate recovery and the current coverage-authorization semantics. Existing native or explicit-full diagnostics are current features, not a dual-version compatibility implementation. Local migrated standards and receipts stay owned by their accepted publication.
Interface 37 adds the optional detail mode and a typed oversized-record retrieval continuation to the existing operation; operation count is unchanged. Install the schema, generated consumers and runtime together and restart/reconnect clients. Analysis, Snapshot, readiness, application and SQLite representations do not change. The existing full-result and compact/batch choices remain available.
Detail requests use the existing operation-owned material scope for both snapshot-backed and proposal-backed Analysis. Each call loads the exact stored Analysis, verifies its captured inputs and checks current lifecycle/revision state. An eligible exact draft projection can avoid replaying the same history; evaluation, whole-section observation binding and page construction remain fresh. Cold, evicted and disabled-cache reads reconstruct the same result. Compact and explicit full-record reads share this path; the independent review, candidate verification, application and recovery replay boundaries are unchanged.
Compact status reconstruction projects counts directly from the already evaluated Analysis instead of constructing and serializing a full result only to discard its detail. Evaluation, current lifecycle and proposal-head checks still run. Calls that already produced a full result and explicit full diagnostics retain that path. This is a presentation-work reduction, not a claim that evaluation, Git capture, authoring or publication become proportionally faster.
Compact pending mutation results carry the next work directly. propose,
revise, analyze, resolve_workflow and resolve_many return a bounded
work page derived from their already-produced immutable Analysis. Missing
facts are presented first; otherwise the page contains required obligations.
The first page has at most eight whole items and 64 KiB of page JSON. Summary
counts still cover all sections. workflow_status remains summary-only, and
detail: "full" retains the native outcome without an additional inline page.
context appears once at the focused result boundary. Focused action
continuations name their operation and remaining caller inputs; submit the
result's exact context with those inputs. The compact summary omits its former
handle, and its details link inherits the same Analysis context. Complete
child work handles remain bound explicitly because they are submitted authority.
A workflow-work-page carries section, observation, offset: 0, total,
items, and optional next. For fact_requirements, items use the existing
fact requirement work contract. For pending_obligations, each item contains
obligation and its executable work handle. Coverage work uses a
coverage-requirement handle, while consumer/impact decisions use an obligation
handle. Read the permitted submission and supply an actual evidence-backed
answer; presentation never supplies that answer.
To retrieve remaining items, add analysis: result.context to work.next and
invoke workflow_details. The resulting standalone page and all its later
next requests retain their explicit Analysis binding. The observation is the
same digest as an independent read of the section: page boundaries do not create
new identity. Another section is selected explicitly against the same context.
When the first complete work item exceeds the compact budget, the successful
mutation returns workflow-work-deferred with code: "WORKFLOW.RESULT_LIMIT",
section, total, and a relative request. That request selects one exact
record with detail: "full", limit: 1 and its observation; add analysis from
the enclosing context. The full read has no compact byte cap and requires an
explicit caller choice. The mutation is not rejected or repeated because its
presentation was oversized. No incomplete record is emitted or skipped.
The page budget counts serialized domain-page JSON, including its continuation, not the enclosing workflow/MCP envelope, dual compatibility representation, or client formatting. Inline construction budgets the larger standalone form before removing redundant parent bindings. It performs no additional Analysis evaluation, provider execution, evidence observation, or publication.
Interface 38 replaces the interface-37 focused result shape in one coordinated
code/schema/generated-projection/consumer change. Restart the MCP process and
reconnect or refresh the client's catalog as indicated by runtime_info.
Old clients must use the new result contract before continuing. Preserve exact
snapshot, proposal, revision, Analysis, readiness and application handles and
their existing store. Request contract 6, result/state 7, handle versions,
immutable historical results, evidence providers and publication guards are
unchanged; no state migration or store deletion is part of this cutover.
Existing read_many and resolve_many should serve ready grouped work. Automatic
analysis in propose/revise means a successful result normally needs neither
another analysis nor a status call. Keep explicit review, application, recovery
and newly discovered decision rounds. Native complete diagnostic results and
standalone paging remain supported. The schema-description client workaround
and MCP structured/text compatibility representation are unchanged.
This increment composes existing owners rather than creating new state or policy. Application and authoring purposes remain host-selected and separate.
Interface 43 replaces the former host-selected input presentation with one
reference-preserving canonical schema closure. Input shapes still select the
purpose-qualified agent variants; schemas retain constraints, literals, recursion
and local definitions. Neither descriptions nor a second renderer carry a fallback
schema. Use describe_input when the client abbreviates a required field. The
native-only cutover owns launch and
consumer replacement; existing evidence and workflow authority is unchanged.
Focused route optionally accepts content with offset (default 0) and limit
(default 8, 1–32). Both purposes use one captured snapshot, one compiled input and
the ordinary purpose-qualified single-read owner. Content contains whole compact
reads for selected unique targets, in reading-plan order. The complete composed
JSON result is limited to 2 MiB; application pages additionally use the
interface-49 page budget. Byte pressure ends
a page before the next whole
read; content.next is a complete route request with identical facts, snapshot,
limit and the next offset. Missing applicability facts remain missing. Reading
plan and unresolved questions are not paged or suppressed.
Nonzero offsets require explicit snapshot authority before capture. An offset past the selected count rejects; equality returns a final empty page. In authoring, a single oversized record or oversized route envelope yields a bounded limit rejection; the caller may explicitly route without content, then read a target with an adequate client. Application routes deliver every selected target with its review label. Failed reads or lifecycle checks expose no successful partial prefix. The existing selection-only route, native query and candidate preview contracts retain their previous behavior. This is paging over a request, not an authorization cursor: changing facts explicitly requests another route.
Only focused propose, revise, resolve_workflow, resolve_many, and review
select generated agent input variants. Each permits a root evidence table of
up to 128 complete native references and typed EvidenceUse values of the form
{"evidence_ref":"name"} at evidence-reference positions. Inline references
remain supported. Each table entry must be used; unresolved, unused or malformed
bindings reject before dispatch. The table cannot contain further aliases.
The facade validates the whole agent input, expands generated reference-use types, and validates the original native input before dispatch. Calls without a table retain the native fast path. Authored strings and arbitrary object keys never gain reference semantics. Native uniqueness, expanded submission-size limits, digest and provider checks, current authorization, immutable work bindings and publication guards remain with their original owners. Aliases confer no authority. Local names and tables are neither persisted nor used after the request; records contain only canonical expanded evidence. Application catalogs and advanced native inputs do not expose these agent variants. Generated sibling-equivalence tests require future native evidence changes to update the corresponding agent family atomically.
Interface version is 39; Analysis request 6, Analysis state 7, handle, readiness, application, recovery and store versions are unchanged. Existing contexts remain usable after process replacement. Restart/reconnect and preserve retained state. There is no remote publication, auto-review, retry or migration in this increment.
The focused suites and agent_efficiency_trace.py qualify schema semantics,
selected text, explicit evidence decisions, real stdio and serialized byte/call
counts. These are not claims about model tokens, billed usage or client rendering.
The plan records supported-runtime, configured-client and independent-review gates
separately from local structural and unit evidence.
describe_input(operation, selector?, expected_catalog?, offset?, limit?) is a
read-only installed-interface observation. It is available in both purposes,
focused and advanced catalogs, with native-only input presentation. Arguments stay flat and
small so discovering an abbreviated input does not require another large union.
The existing compiled interface selects the operation's purpose/agent input root. The actual published operation set further limits discovery. A definition is selectable only within that root's transitive input-reference closure; output schemas, another operation's private definitions, and unpublished operations are not made visible. Missing and off-purpose operations return the same bounded unavailable result. It observes the running process rather than hot-loading disk.
A first operation-only request selects its input root and returns its catalog
identity. A selector is a returned named definition, including a name in
#/$defs/Name. Every selector or nonzero offset requires expected_catalog.
Mismatches return INPUT_DISCOVERY.CATALOG_CHANGED; no stale cursor is reinterpreted.
The catalog digest is the existing RuntimeIdentity digest, not a new handle/store.
Root, selector, dialect, interface version, record offset, closure total and exact
next-call arguments are returned. There is no snapshot requirement or capture.
Each record contains a name and schema_json, an exact serialized JSON Schema
definition. Schema documents are data; structured mutation arguments stay
structured. Using document strings avoids a new recursive meta-schema projection
or a schema evaluator in the discovery service. Literal/default/enum data and
all existing constraints are preserved. Definition-reference traversal uses the
contracts package's structural owner; recursion is visited once. Breadth-first
order puts containing objects and union choices ahead of their descendants.
The default page is eight records, the maximum sixteen, and the complete domain
result JSON is at most 16 KiB with the MCP serializer's normal escaping/separators.
This is not a bound on the whole transport frame (which also carries the text
copy and runtime metadata), interpreter memory or model tokens. Byte pressure
ends before a whole record and supplies next; an oversized first record returns
INPUT_DISCOVERY.RESULT_LIMIT / unsupported with no partial schema. No unbounded
retrieval is implied. All current published input records are qualified against
this bound. A future oversized record keeps that discovery path unqualified until
it is addressed by its owner.
The selected closure is complete only after all of its pages are collected.
Clients may instead select just the required edit, submission or nested input
from references in an earlier page. A schema record alone is not a standalone
validator unless it has no unresolved references. To assemble a standalone selected
schema, use the records as $defs, $ref to the returned selector, and the returned
dialect. The operation's root is also reported even when a narrower selector is
being inspected. No example, inferred rationale or fabricated evidence is injected.
Discovery failures have their own bounded input-contract-rejected-result algebra
and MCP isError: true. Valid results have isError: false. Application and
authoring results carry their purpose but expose no repository paths or private
state. The reference CLI and direct native facade observers describe their full
purpose-qualified catalog, matching their available operation set.
Their identities can differ from focused MCP; reuse selections only in matching
catalogs. The native facade runtime_info digest now includes the actual complete
catalog rather than a list of
operation metadata, so changed nested definitions invalidate discovery selections.
Interface 40 is an additive observation capability and catalog update. All prior
native/agent mutation definitions, Analysis, readiness, application/recovery and
SQLite representations are retained. Restart/reconnect without migrating or
removing stores. Actual agent-client qualification remains distinct from schema
or transport validation. The model must acquire the relevant shapes,
construct valid authoring requests, use single and batched decisions with real
request-local evidence, and reach explicit readiness without publication or source
file/schema fixture access. A recursive tail may remain unknown when its required
shape is available through this qualified discovery path.
route adds optional detail: compact | full. Compact is the focused authoring
default and returns compact-route-result. It preserves canonical facts, selected
entries and their causes, all typed unanswered questions, and selected dependency
closure. unresolved_policy_count counts reading-plan entries not selected; it is
not evidence those policies do not apply. explanation is a complete full-route
request anchored to the same snapshot and facts. Full focused route retains
agent-route-result; native queries and candidate previews keep prior contracts.
Application results keep their own projection and never disclose private rule explanations.
Content paging retains detail, facts and snapshot. Rule evaluation and missing vs
known-empty semantics are unchanged; compact presentation does not build full rule
expression output merely to discard it.
relationship_groups(snapshot?, offset?, limit?) reads registered vocabulary in the
selected graph. Its result records purpose, snapshot, total, offset, whole group
items and next arguments. Each item contains id, registered meaning and traversal
policy, not source locators, validator implementation or extension metadata. The
application view supplies only permitted groups. A group
can be registered with no relationships for a target. Default 8/max 32 records and
16 KiB page JSON bound the result; oversized records return unsupported without
truncation. Nonzero offsets require the exact snapshot, and final lifecycle failure
discards the complete page. Unknown focused related queries return the same first
page as optional rejection feedback (registered targets are checked first). Native
application queries share that behavior; native authoring and candidate queries keep
existing authority-specific failures. No guessed alias or alternate graph is used.
Contract-invalid calls retain invalid rejection semantics with optional
input_feedback. The existing jsonschema validator still decides validity. The
contracts runtime projects at most eight value-free issues with an 8 KiB issue-array
budget, from a bounded diagnostic walk. Each issue has an instance pointer,
location_exact, keyword and message. Known disjoint tags focus causes; ambiguous
unions stay explicit. Dynamic instance-map keys are redacted, and excessive pointers
are non-exact rather than silently clipped. Declared missing fields and constraint
bounds are safe schema data; submitted values, raw validator messages and arbitrary
keys are not emitted. Repeated required-field errors are deduplicated. The original
first-error cause tree remains internal. Success does not construct diagnostics.
The facade supplies an operation-specific describe_input request; standalone runtime
and discovery observers use the same safe issue projection. Explicit request-local
evidence binding rules produce their own safe issues without another validator.
Input rejection occurs before any Engine proposal, decision or publication call.
Interface 41 versions these public observations and the default route shape. Previous native/agent mutation declarations, Analysis request/state, handle, readiness, application/recovery and SQLite versions are unchanged. Upgrade producer/consumers and refresh the catalog together; preserve stores. No old-data conversion, implicit negative fact, automatic review, publication or remote operation is introduced. Input compatibility is retired by the interface-43 cutover below. Catalog inventory distinguishes descriptions from schema JSON and does not claim model-token savings. See the current plan for measured cost/benefit and limits.
describe_output is a read-only companion to describe_input. Both are served by
ContractDiscovery over the same installed interface and actual purpose/catalog.
Output discovery selects only the requested operation's qualified result roots.
It does not inspect standards state, query Git or create snapshots or proposals.
Start with {"operation":"review"}. The result provides roots,
root_schema_json, schema_digest, and whole definition records. Read every page
of the unselected result to reconstruct the complete operation schema:
parse root_schema_json and set its $defs to the map of record names to parsed
schema_json. dialect identifies Draft 2020-12. The digest binds the canonical
JSON of that complete schema (UTF-8, ASCII escaping, sorted keys, compact separators),
without adding other fields. It covers the structured domain result, not MCP's
outer content/structuredContent/isError wrapper.
An explicit selector names a returned/referenced output definition. Selected
pages cover that definition's closure, not the complete result algebra. roots,
root_schema_json and schema_digest still identify the complete operation result.
Follow next unchanged. Selected and nonzero-offset calls require the original
expected_catalog; a changed catalog rejects rather than combining contracts.
Pages use the existing defaults: eight records, at most sixteen, and at most 16 KiB
of domain result JSON. An oversized whole record has an explicit unsupported
outcome; no partial schema is presented as complete.
The host can select --output-schemas eager (default) or
--output-schemas on-demand. This choice is independent of the native-only input
contract. Eager catalogs retain
complete outputSchema entries for existing clients. On-demand catalogs omit that
optional MCP field rather than replacing it with a permissive schema. Each tool
instead includes _meta["standards-engine/output-schema-digest"], binding its full
output contract into the existing catalog digest. Output-only changes therefore
invalidate earlier discovery selections. Input/output contract digests and operation
capabilities are distinct: a shared schema does not grant authority to another action.
Clients can retain an exact reconstructed schema by its digest and reuse it across operations with that digest. The Engine adds no client cache or session authority. Ordinary success handling requires no extra discovery call: results retain exact values, kinds, contexts, typed failures and continuations. Requests and generated results still use the same validation in both delivery choices. Matching structured results and JSON TextContent are preserved.
No existing operation, result, handle, Analysis request/state or SQLite definition
is replaced by this addition. Input discovery's wire contract is unchanged.
Interface 42 adds one operation and a host catalog option; restart/reconnect to
observe it and preserve all retained state. Eager is the supported default until
on-demand is qualified on the actual host. Do not infer model-visible size or client
validation behavior from serialized catalog bytes alone. The existing client and
model qualification harnesses now accept --output-schemas and retain canonical
output validation in their observer, without supplying those schemas to the model.
The owner's native-only decision retires the compatibility input-presentation
promise. SchemaMode, the Python schema_mode arguments, --schema-mode, the
embedded-schema description list, recursive inlining, and size-based selection
are removed together. There is no one-value enum or no-op alias. A former native
launch command is updated by removing its obsolete pair, not by selecting a new
flag. Old options reject before installation/store work; normal startup retains
purpose, operation scope and the existing output delivery default.
Catalog projection applies schema_closure once to the qualified input root.
Bounded describe_input and describe_output remain exact, no-store observers.
Output delivery stays eager by default and on-demand when explicitly requested;
omitted output schemas retain their existing digests and output-only invalidation.
MCP structured content and its matching text form are unchanged.
The interface edition versions launch/composition replacement, not persistence. Canonical schema identity, Analysis request 6/state projection 7, handles, stores, readiness and recovery formats are unchanged. Refresh catalog-bound selections when their digest changes. Observe existing workflow contexts through their usual operations; do not migrate or erase them because a presentation was removed.
Live qualification commands have no input-mode option. Reports retain the constant native label only as provenance. Current-source replay accepts native recordings only when source/catalog requirements match; it cannot reconstruct a retired renderer. Keep historical files/verdicts unchanged and use their original pinned tooling when necessary. Private observer validation derives exact result contracts from canonical roots rather than constructing a duplicate eager catalog.
For the known Codex deployment, keep --output-schemas on-demand, remove only the
old --schema-mode pair, restart through the host, and verify the reconnected agent
catalog. A fresh disposable model-authored path ends at independently verified
readiness, not publication. Supported-runtime CI and independent material review
remain separate evidence; earlier successful client runs do not certify new code.
RouteCall.facts is a required RoutingFactAssertions map. Each value is boolean,
null, string, a unique string array, or a closed object containing only
state: unknown | known-absent. Existing six fact types determine which raw values
are valid after exact snapshot selection. The common static schema deliberately
cannot infer a type from a caller-controlled name. Old typed envelopes, arbitrary
objects and numbers are rejected rather than auto-detected or coerced.
routing_inputs.py translates a statically validated assertion to the selected
FactSchema's declared type, preserving the supplied name/alias, and invokes its
existing binder once. FactSchema.require owns required-name lookup and its existing
canonical error. Canonical FactSet/FactValue, aliases, Unicode normalization,
set membership and three-valued evaluation retain their meanings and owners.
The focused reverse projection is also checked by its generated contract before
selection. If different raw strings normalize to duplicate set entries, the
focused request returns safe invalid feedback rather than violating its result
contract. This does not redefine the canonical binder or native query semantics.
The bound selection helper reuses the existing algorithm and program schema-digest
checks. Native query/preview callers still bind canonical typed inputs before
selecting; they are not a fallback for old focused requests.
Application dispatch binds focused input and returns the complete selected content
closure with review labels (interface 49 removed the earlier Router and closure
qualification step). The invalid-input adaptation is confined to that known binding
boundary, not a general change to lifecycle errors. Authoring returns
ROUTE.INPUT_INVALID; application returns APPLICATION.INPUT_INVALID. Both include
bounded existing input_feedback with a route describe_input hint. Known fields may
be named; unrecognized input keys/values are not echoed. This is one fixed-prose
constraint issue, not a second validator. Required-name resolution happens before
the binding pass, so an undeclared later name may precede an earlier type error in
multi-error inputs. After resolution the canonical binder retains its order.
Canonical bound facts project through one reverse function to focused authoring CompactRouteResult/AgentRouteResult facts and to both purposes' content.next calls. Canonical IDs, sorted normalized sets and explicit unknown/absence are retained. The full explanation is the same snapshot and fact binding, with full detail. Changing facts explicitly changes selection; pagination does not. Policy text, content bounds, current lifecycle checks and no-extra-capture/compile behavior stay.
Static rejection happens before capture. With no snapshot supplied a dynamically invalid request may first capture accepted authority; no invalid request creates a proposal, decision, review, publication or successful route. This is an explicit failure-stage move, not a claim of identical static acceptance for different syntax.
Interface 45 versions the focused wire replacement and its direct consumer cutover. Request contract 6, result projection 7, native route definitions, preview contracts, material hashes and persisted state are not migrated. Historical saved focused calls 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.
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.
Successful apply now reconciles the selected local checkout after recording the
durable applied outcome. Explicit recover/recover_application with
action: "complete-publication" also attempts reconciliation, including for an
already applied application after reopening. It requires current recovery and
application authorization. Default recovery and workflow_status continue to
observe without changing the checkout.
Reconciliation is restricted to a checkout on refs/heads/main whose current
head is the exact admitted candidate. It compares only paths changed between
the expected predecessor and candidate. An overlapping local edit, staged
change or untracked destination is preserved and reported as conflicted; this
blocks the checkout update as a whole. Other branches, detached heads, diverged
main and unsupported layouts are never repaired automatically.
Repository Git holds conventional files-backend HEAD and main-ref locks,
re-observes the checkout, and delegates the two-tree index/worktree update to
Git read-tree -m -u. Git owns index locking and its final overwrite checks.
Unrelated staged, unstaged and untracked work is retained. No stash, reset,
branch switch, new publication or domain-store migration is performed.
Reconciliation is separate from the durable standards publication. A held lock, unsupported layout or checkout I/O failure leaves publication applied and returns an unavailable checkout observation. Filesystem failure can leave a partly updated checkout; subsequent observations report its actual state and explicit completion may retry against the same publication identity. There is no rollback of the accepted commit or automatic retry. A current checkout is left untouched. Refresh generated contracts and reconnect for interface 47; request contract 6, result projection 8 and persisted identities remain unchanged.