---
title: "Source: served_context.md"
description: "Generated page for the indexed contract source served_context.md: its schema fields or contract text, and its published text."
slug: /reference/sources/served-context
order: 18
visibility: public
redirects_from: []
---

# Source: served\_context\.md

Generated automatically from the [published contract sources](/cloud/reference/about/#contract-sources).

Source path: served\_context\.md.

## Contract text

### The Served Context — One Source, Three Forms

### Purpose

This document defines the source for the service\-contract forms required by API\-L0\-09: human documentation, MCP discovery, and the agent\-consumable authoring bundle\. The indexed Markdown and JSON files remain readable without a running server\.

The index is `schemas/served_context.json`\. A test in the platform's suite checks that the indexed files exist and that required schemas are included\. This document owns the rules; the index lists the files\.

The server derives MCP discovery and skills from the catalog and packages the indexed contracts in its authoring bundle\. At the site render \(the site render script, which the site publish and `npm run site:render` run; PLD\-L0\-69\), the reference generator generates the human reference from those sources alongside the narrative manual, and tzdocs checks and renders the combined corpus\. Source reproductions and code\-derived registration metadata follow MCP\-05 and CTX\-03; skills follow CTX\-04 and API\-L0\-10, and action payloads are in `schemas/action_payloads.json`\.

Requirements are numbered CTX\-nn\.

### The source

CTX\-01 \(decided\): The one source is the contract set of this folder: each contract's rules in its requirements document, its enumeration or schema in `schemas/`, and the wire schemas joining at C2\. The three served forms are generated from it and authored nowhere else\. An entry of the words override file stands beside its source until the entry is removed, and the source stays the fallback and the fold's target \(PLD\-L0\-114\)\. The index at `schemas/served_context.json` names what is served: a contract absent from the index is unserved, an index row naming a file that does not exist is a defect, and a schema on disk the index omits is one\. The suite refuses both directions, so the index cannot quietly shrink or the source quietly grow past it\.

The library's serving is indexed by the library catalog under `library_catalog.md`'s rules \(Q\-239\), and this statement's guarantee extends to it explicitly\. A library entry absent from the catalog is unserved, a catalog row naming what does not exist is a defect, and the suite holds both directions there too\.

CTX\-02 \(decided\): Static readability is the floor: every indexed source is plain Markdown or JSON, readable from the repository or any copy of it with no server, no build, and no tool beyond a file reader\. That floor is C1's exit made permanent rather than met once\. The generated forms add addressing, packaging, and rendering; they add no contract content, and any build\-registration metadata follows CTX\-03, so a tool that reads the raw source early reads the same truth the served forms deliver later\. An entry of the words override file is the one exception, while it stands \(PLD\-L0\-114\)\.

CTX\-03 \(decided\): The three forms derive contract content from the indexed sources: human documentation renders it, discovery descriptions quote it \(MCP\-05\), and the bundle packages it\. No form independently authors contract facts\. An entry of the words override file that changes a contract fact rather than its wording has its source corrected by a fold in a following landing \(PLD\-L0\-114\)\. Correct a missing or incorrect contract fact in its owning source and regenerate the affected forms; correct a generator defect in the generator\.

The human reference may also show registration status derived from the production code for the same build\. Label it as build metadata, separate from the contract, and verify that it matches the default runtime dispatcher\. Registration does not guarantee access for a particular caller or availability of a configured service; state those limits beside the status\. Do not infer registration from the presence of a payload schema\. This metadata exception does not permit a second authored capability list or additional contract facts\.

CTX\-04 \(decided\): The skills are served beside the bundle under the same rule: the set derives from the enumeration of actions — no hand\-kept list — and each skill is generated from the capabilities it drives\. A skill naming an action the contract lacks therefore fails generation rather than shipping a recipe for a capability that does not exist\.

CTX\-05 \(decided\): Discovery's substance is the index: what a newly connected tool learns exists is what the index serves — the overview first, then the contracts by subject\. Discovery therefore requires no prior knowledge of Turn Zero Cloud's vocabulary, because every term a listing uses is defined one indexed read away\. The same reads arrive as MCP resources and as the observe tools CTX\-07 defines; their catalog, text and visibility share one source\.

CTX\-06 \(decided\): The bundle carries the operating disciplines an agent must apply, the schema\-evolution discipline first\. That discipline comprises schema changes as migration files in the customer's repository, destructive changes flagged as such, the development command set — migrate, reset, seed, status, diff, snapshot — and production changes through the migration action \(PLD\-L0\-56\) with the version handshake \(SVC\-L0\-11\)\.

The library\-first discipline is the second: before hand\-building a capability, the agent lists the library \(`read_library`\), reads the candidate entry \(`read_library` with `entry`\), and takes it through the served skill \(`add-library-entry`; `update-library` for a newer version\) into the project's own folder \(API\-L0\-14; SPM\-L0\-49\)\. This discipline is the serving half of tzTeam's library\-consulting promise \(REG\-26\), followable by an agent connected to this surface alone\. Where the agent holds no tzTeam registrar, the skill's kit\-free ending is its proof: `read_library` with the vendored folder's manifest rows as `installed` \(SPM\-L0\-49\), every taken entry answered `current` \(LC\-06\)\.

The index names each discipline as a guide entry with the commands it must teach\. The served guides now exist and distinguish available commands from planned migration and version\-handshake behavior\. Evaluation must establish that an agent can successfully follow these guides; the existence of guide text alone does not satisfy that obligation\.

CTX\-07: Tools\-only discovery uses read\_context, read\_documentation, and search\_documentation \(CTX\-10\), observe actions of platform\_context recorded and metered by the ordinary dispatcher \(MAPI\-06\)\. The read\_context action with no `id` answers the visible ordered catalog\. Its entries are overview, service\_contracts, manifest\_schema, bundle, each deduplicated indexed source addressed as source:&lt;relative indexed path&gt;, guides as guide:&lt;subject&gt;, live and grant\-listable skills as skill:&lt;name&gt;, each listable action's two wire shapes as payload:&lt;action&gt;, and two documentation entries per tree the connection's account may read\. A paged skill's parts follow its entry as skill:&lt;name&gt;:&lt;part&gt;, listed under the same grant filter as the skill and read through read\_context as any entry is \(MCP\-06\)\. The plane serves those skill entries, which CTX\-04 derives; a `skills:<product>` entry lists the skills a product's own server serves\.

An overview:&lt;product&gt; entry, overview:tztrack or overview:tzmesh, is that product's own practices, and not the overview MCP\-05 states\. It opens with a short header the plane composes\. The header says that the practices name the product's tools bare and that each is called through this connection with the product's prefix\. For tzTrack it also names the acts that run here under the plane's own rows, and the neighbour MCP\-13 names\. For tzMesh it also says to pass `as`, the participant's id `register` answers, on every later call that takes it, since the door session the connection reaches tzMesh through may be opened afresh \(MCP\-14\)\.

Its MCP server's instructions resource follows, relayed whole as the front caches it with the server's list \(MCP\-14\), so the server keeps the one source of its practices\. The entry follows the overview where MCP\-14 lists the product's rows to the connection, and stands on no other connection's catalog, where a read of it refuses context\_not\_found\. A read where the front holds no text refuses context\_unavailable, naming the server's address\.

The catalog also lists the `tools` entry, a compact index of the tzCloud tools the connection lists\. Its first line says once that a tzCloud tool's longer text, where it has one, is its reference page, which `read_documentation` reads, and gives that page's path with the tool's name in it\. Then it holds one line for each of the plane's own rows the connection's tools/list carries, in that order\. Each line is the tool's name, a colon and a space, then the opening sentence of its description as MCP\-05 reads it\. An opening longer than `tool_index_sentence_length` code points keeps its first words, which state the tool's purpose, to the last that fits beside an ellipsis that ends it, and splits no word\. A first word that alone runs past the bound is cut on a code\-point boundary\.

For a wire read, MCP\-08 selects the company's origin for this index alone; the skill and payload entries still read no MCP address\.

The `tools` entry's last line, on a connection served products whose rows MCP\-14 lists, names each such product's own entry, `tools:<product>`\. That entry holds a line naming the product and the prefix its rows carry here, then one line for each row MCP\-14 forwards from the product's server, in the listing's order\. Each such line is the tool's name, a colon and a space, then the whole opening sentence of its description as MCP\-05 reads it, cut nowhere, so a reader learns what each of the product's tools is for\.

The `tools` entry and each `tools:<product>` entry hold at most `tool_index_max_length` code points on every connection but an operator's, below `text_max_limit`, so one read with `limit` set to `text_max_limit` returns each whole however many products the account holds\. An operator's `tools` entry may run past one read and pages by `next_offset`, as any long entry does\. No line is left out to meet the bound\. The two bounds are set so that one read's answer, on the tools served, stays under 10,000 bytes, for a host that cuts a longer tool output\. Both bounds live in schemas/served\_context\.json beside the text limits\. The `tools` entry follows the overview and the overview:&lt;product&gt; entries, the product entries follow it, the `skills:<product>` entries follow them, and each text is served once, with no structured copy beside it\.

The catalog lists one `skills:<product>` entry for each product whose rows MCP\-14 lists to the connection, from the front's predicate alone, so listing the catalog reads no server\. A read of it warms that product for a listing and answers each prompt MCP\-14 lists from the product's server, under its prefixed name with its description and arguments\. Where there is none, it answers one line saying the server serves no skills\.

Each such prompt reads as `skill:<prefixed name>`, listed by no catalog page and outside the catalog's stamp\. That read warms as a `prompts/get` does, asks the server through the front with no arguments, and answers the server's text, or its refusal in its words, counted as a forward \(MCP\-14\)\. A client that renders prompts runs a prompt with arguments itself\. On a connection where MCP\-14 lists none of the product's rows, both entries refuse context\_not\_found, and a name the front does not list refuses the same\. A skill's read whose server does not answer, and a read of either entry whose warmed view holds no list for the product, refuse context\_unavailable, naming the server's address\.

A payload:&lt;action&gt; entry is one JSON document holding the contract version, the shared shapes that action's request and response reference, and the request and response, derived from schemas/action\_payloads\.json and hand\-kept nowhere\. A client therefore reads one action's shapes in one page at the configured maximum limit where they fit, and in two where they do not, instead of paging the whole file, the whole\-file source row standing beside them\. An entry whose shapes run past two pages is paged as any long JSON entry is\.

The documentation entries are docs:&lt;tree&gt; for each tree's index and docs:&lt;tree&gt;:full for its whole text, the tree one of cloud, tzteam, tzdocs, tzmesh, and tztrack \(PLD\-L0\-69\)\. A gated tree's two are listed to a holder of its product profile alone, the predicate ACB\-L0\-82 owns\. Each documentation entry names read\_documentation, its tree, its part, and its authentication requirement\. The read\_context action accepts an exact catalog content identifier, never an arbitrary path or URL, and beside the catalog's identifiers the `manifest_schema` member identifiers the next paragraph states and each `skill:<prefixed name>` the connection is relayed\. The read\_documentation action accepts only those five tree names and, beside a name, or in its place where a `page` route names the tree, four optional members: `part`, `page`, `query`, and `section`\. `section` and `query` beside `page` narrow the page read's answer to one section or to the page's matching lines\.

Through the rename's window the tzteam tree's earlier name, blueprint, is read as it where a call names a tree: in `tree`, as a `page` route's first segment, the route then read under the tree's base path, and in the `docs://blueprint/` resources \(PLD\-L0\-69\)\.

The `manifest_schema` entry's summary names its member identifiers: `manifest_schema:<member>` for each top\-level member of the schema's `properties`, and `manifest_schema:services:<kind>` for each kind a `oneOf` branch of the `services` member admits, composed from every branch whose `kind` admits it\. A kind's own branches, whose `kind` is a const, come first and the shared ones after, each group in schema order, so a first chunk shows the kind's own shape\. Each answers the fragment as its own JSON text with the `$defs` it references, paged and stamped as any JSON entry is, listed by no catalog page and outside the catalog's stamp\. Where exactly one member has a part, split at its colons and underscores, that is an unknown identifier's last colon\-separated part, compared without case, alone or less a trailing s, the read answers that member, its `id` naming it\. Any other unknown member refuses context\_not\_found naming the members\.

This paragraph qualifies the sentence above on an unknown member's likely member\. One alias counts as a member's part, compared as its parts are: `secret` for `settings`, which binds a stored secret \(MAN\-14\)\. That read's answer also carries `note`, a sentence naming the identifier asked and the member answered, so a caller learns its identifier named no member\. A read by a member's own identifier carries no such sentence\.

Where the identifier's last part is a property the answered member's shape declares, at its top or in one of its alternatives, the note adds one sentence saying so\. So `manifest_schema:schedules` is told that `schedules` is a property inside `manifest_schema:services:schedule`, not a member of its own\.

The `part` member is `index` \(the default\), `full`, or `outline`\. The outline is the index's page lines in the manifest's order, each followed by one indented line per heading of the page below its title with its anchor\. The plane composes the outline from the tree's manifest `docs.json` \(PLD\-L0\-69; tzdoc:TZD\-L0\-05\), the index's own form untouched\. The `page` member is a route the tree's manifest lists\. It is given as the index prints it with or without its trailing slash, or without the base path with or without the slashes around the rest\. The home page's route is the base path or `/`\. A `page` read answers that page's Markdown copy from the served version, so the generated reference is read page by page as the index promises\.

Where `tree` is absent, read\_documentation takes the tree from the first segment of the `page` route when it names one of the five trees, each tree's base path being its name \(PLD\-L0\-69\)\. A `page` value beginning with the estate's public origin, which a completed answer's `page` carries \(PLD\-L0\-85; MCP\-12\), loses it after the length bound has read the value as given, so that `page` passes in as it is\. The call then runs as a call naming that tree runs, so a gated tree and a tree the served version lacks are refused as for a named tree\. Its record names the tree read from the route as it names a given one\. A call naming neither `tree` nor a `page` whose first segment names a tree refuses invalid\_request naming the trees the connection may read, its record naming no tree, the bare page marker where a `page` was given\.

A call carrying a `query` not read as left out and no `page` is refused as the next paragraph but one states, ahead of the tree, so one naming no tree meets that refusal and not the one before\. Its record names docs::search, the tree's place empty, where it names no tree, and docs:&lt;tree&gt;:search where it names one\.

The `query` member is a few words, read as CTX\-09 reads them\. The query is at most `query_max_length` characters, and a query within that bound that holds no word, empty or whitespace alone, is read as if the call had left `query` out\.

A `query` without `page` is refused `invalid_request` ahead of the identity, the tree and the excluded pairs, the refusal naming search\_documentation \(CTX\-10\), which searches the documentation\.

Beside `page`, `section` names one section by the manifest's anchor or by a heading's plain text, a text two headings share resolving to the first in page order, and the read answers that section alone\. Where none matches exactly, the value names the first section in page order whose anchor or heading text matches it with both lower\-cased, a leading `#` dropped, each run of characters other than letters and digits one hyphen, and outer hyphens trimmed\. A `page` value carrying `#` and an anchor is read as that page with `section` set to the anchor, so a hit's link passes in unchanged\.

Where the heading has child headings, the answer closes with one line listing the children's anchors, so the reader continues in one call\. `section` is bounded as `page` is, and a value matching no heading refuses context\_not\_found naming `part` `outline` beside the page as the way and as many of the page's anchors as the refusal's budget holds\. Rank anchors by how many words of the value they match, most first, with ties in page order\. Fold the value and anchors as a section match does, then split them into words\. Words match when equal or when one begins with the other and the shorter holds at least three characters\. Where a page's sections carry no anchor, the identifier, the refusal, and the children line carry each heading's offset in the anchor's place, the refusal naming the headings and offsets instead of the outline\.

Beside `page`, `query` answers the page's lines holding a query word read as CTX\-09 reads it, each with `context_lines` lines of context before and after and prefixed by its code\-point offset in the page, so a `page` read at that offset continues there\. Where that line is a section's first line of text and the two fit within the limit, the read starts at the section's heading\. `part` other than the default excludes `page`, `query`, and `section`; `section` requires `page`, excludes `query`, and names the section twice beside a `page` route carrying an anchor; a call naming an excluded pair is refused invalid\_request naming the one to drop\. A route the manifest does not list refuses context\_not\_found with the manifest's form in the detail\. A served version lacking the manifest or the page refuses context\_unavailable\.

Every read requires the same identity as the trees' documentation resources \(PLD\-L0\-69\)\. Every read answers under the same paging, stamps, and response shape as the index, the page, the section, and the page's lines each paged within their own text, a bare `page` read's first chunk alone adding `headings`\. A signed\-in connection naming a gated tree its account may not read is refused as a handler violation, invalid\_request, its detail naming the trees that connection may read \(ACB\-L0\-82\)\. The catalog lists two documentation entries per tree and no page, outline, section, or query\.

The identifiers are read\_documentation's alone, stamped as any text is: docs:&lt;tree&gt;:outline, docs:&lt;tree&gt;:page:&lt;slug&gt;, the slug empty for the home page, docs:&lt;tree&gt;:page:&lt;slug&gt;\#&lt;anchor&gt; for a section read, docs:&lt;tree&gt;:page:&lt;slug&gt;:search:&lt;hash&gt; for a page's lines, and docs:&lt;tree&gt;:page:&lt;slug&gt;:outline for a page's outline\. The hash is the first sixteen hexadecimal digits of the SHA\-256 of the query's lower\-cased words as CTX\-09 reads them, the stop words among them, joined by one space\. A section read's record, a page's lines' record, and a page's outline's record name the page's marker with its route, as a page read's does\. The catalog stamp hashes its complete ordered JSON entries; text stamps hash the complete text before paging, with one exception: a `page` read with `query` is stamped with the page's complete text, so its listed offsets and its own continuation carry the page's stamp\.

A `page` read's first chunk, where more follows, answers `headings` ahead of `text` where the page holds a heading of depth 2 or deeper outside a fenced code block\. Each entry is one such heading's text and the code\-point offset where its line starts in the served copy, in the page's order\. A page holding more than 40 such headings lists those of depth 2 alone, and answers no `headings` where it holds none of that depth\. Each offset is a place where a chunk can start, so a read naming it with that chunk's stamp starts at the heading's line\. The continuation names `query` for a passage's words, `headings` for a section where the chunk answers them, and `section` for one section's text; a section read, a page's lines, and a page's outline carry no `headings`\. A later chunk, and a page one answer holds whole, carry no `headings`\.

A tree's index or outline read that holds less than the whole text closes every chunk's continuation by naming search\_documentation for one step's words\. A read of `manifest_schema` itself, not one of its members, closes the continuation of each chunk that more follows by naming the member reads\.

The `headings` member lists at most `headings_limit` entries, the first in the page's order, counted after the fall to depth 2\. Each entry's text holds at most `heading_max_length` code points, a longer text cut on a code\-point boundary\. Both bounds live in schemas/served\_context\.json beside the text limits\. Where either bound cuts the list, the continuation says the list is cut, in a sentence no longer than the one it replaces, and still names `query`\.

Resources, prompts and readers use the same content readers: a fully reconstructed tool result is the same UTF\-8 text\. Visibility and authorization are recomputed on every call, including continuation; a prior stamp grants no access\. The bundle's catalog is the anonymous view's complete source catalog\. A tree the served site version lacks \(PLD\-L0\-69\), or a missing indexed file, refuses context\_unavailable \(503\), an unknown or unavailable\-to\-this\-view content identifier refuses context\_not\_found \(404\), and a changed continuation refuses context\_changed \(409\)\. Pagination bounds live in schemas/served\_context\.json: catalog pages have a fixed positive entry limit; text pages have a positive default and maximum measured in Unicode code points\. Requests use a safe nonnegative integer offset, default zero, and an optional SHA\-256 stamp; text reads may supply an integer limit from one through the configured maximum\.

This paragraph qualifies the limit's range above\. A read\_context or read\_documentation call whose `limit` is a larger safe integer reads at the configured maximum, its answer's `note` saying so; read\_library with entry refuses it\.

The read\_documentation, read\_context, and read\_library with entry actions begin and end a chunk where a reader can stop: a line start outside a fenced code block, a block's opening line, or the line start after its close\. A block longer than the limit also holds the last line start within the limit of its opening line and of each such place\. A line longer than the limit, or a text with no line end, holds a place at each limit's length from its start\.

In a JSON entry, a line start inside a member of the first or second depth shorter than half the limit is no such place\. A member runs from the start of the line holding its name to the start of the line after the one holding its value's end\. Its depth is the number of braces and brackets open around its name\. Where members sharing a line would leave more than the limit between two places, the last line start within the limit of the place before is one\. A JSON entry is a read\_context entry served as application/json, or a read\_library with entry file whose path ends \.json and whose content is text, that parses as JSON\.

In a text that is not a JSON entry, the line starts after a heading line of depth 2 or deeper outside a fenced code block are no such places, through the start of the first line after it that is not blank\. Where that line is itself a heading, its line start stays a place, so every offset `headings` lists starts a chunk\. Where that first line opens a fenced code block, the block's opening line is no such place where the heading and the block together fit within the limit, and is one where they do not\. Where these places would leave more than the limit between two others, the last line start within the limit of the place before is one, as for a JSON member\.

A chunk begins at the last such place at or before the offset asked and ends at the last one within the limit past that offset\. Chunks followed by next\_offset under one limit hold at most the limit, and chunks asked at every multiple of the limit join with no gap or overlap\. Each answer's offset names where its text starts, a chunk asked at another offset re\-reading less than one limit before it\.

HTTP GET normalizes only canonical unsigned decimal query strings; JSON and MCP use integers\. Handler violations refuse invalid\_request; MCP schema violations retain the protocol’s own error shape\. Offset greater than zero requires a stamp\. Any supplied stamp must match the complete current visible catalog or rendered text, hashed as UTF\-8; an offset past the end refuses\. Responses name stamp, offset, total and next\_offset \(null at the end\), beside entries or id, mime\_type and text, with `headings` on a bare `page` read's first chunk alone\. A read\_context or read\_documentation answer holding less than the whole text also names continuation, ahead of text and outside it\. It states in words the characters read and either the next offset with the answer's stamp value or that this is the last chunk\. IDs are bounded by the configured length and are allowlisted map keys, not input to path resolution\.

The `page` value as given is bounded by the same configured length\. The identifier a page or a query answers under is the plane's own composition, no input and not re\-bounded\. The page's copy is read at the path the manifest's matched entry names and never at one built from the caller's string\. Records name as their subject the catalog, the exact content ID as asked, or the documentation tree with its part, its page route \(the bare marker docs:&lt;tree&gt;:page for a page refused as invalid\), or, for a query, the bare marker docs:&lt;tree&gt;:search\. A record never names a query's words, which are the caller's own and are recorded nowhere\. Records retain the actual credential and application attribution\. No personalized global cache or server\-held cursor is introduced\.

This paragraph qualifies the excluded pairs for two readings\. `part` `full` beside `page`, with neither `section` nor `query`, is admitted and reads that page whole, as `page` alone does, under the same identifier and record\. So a reader asking for the whole text of one page is answered rather than refused\. `part` `outline` beside `page`, with neither `section` nor `query`, is admitted and reads that page's own lines of the outline under its own identifier, an anchor on the route read as the page it names\. Its anchors are the manifest's, as the tree's outline's are, on a page whose sections carry none among them\. So a reader asking for one page's headings is answered without reading the whole tree's outline\.

This statement records a use of MAPI\-02's shape clause on list\_context's response `tree` and read\_documentation's request `tree` in `schemas/action_payloads.json`: each names `tzteam`, the tzTeam tree's name from the product rename, in place of `blueprint`\. The request's enum keeps `blueprint` as the earlier name through the rename's window\. The platform then held 2 builder accounts that each held a live application, synthetic accounts excluded, read at the change\.

This paragraph qualifies the paragraph that states the `page` member, for a page that moved\. The tree's manifest lists its moves, each a route a page was read at before and the route of the page it moved to \(tzdoc:TZD\-L0\-05\)\. A `page` naming a move's earlier route, in any form that paragraph admits for a listed route, reads the page it moved to as that page's own route reads it\. The answer's `moved_to` then names that page's route\. A route the manifest lists as a page is read as that page, never as a move\. A move to a route the manifest lists no page at reads nothing and refuses as an unlisted route does\.

This paragraph qualifies the sources' rows above for an action the public view leaves out \(CTX\-08\)\. A `source:` row, the `bundle`, and a `guide:` row read through CTX\-08's public view on a connection whose credential holds no staff grant, the anonymous reader's among them\. An action whose `clients` names `browser_call` alone has its `payload:<action>` entry listed and read only by a credential holding a staff grant; every other caller reads that identifier as absent\.

This paragraph qualifies the `page` paragraphs above\. A `page` names a reference page outside the public view where it is `/cloud/reference/actions/<slug>/`, in any form those paragraphs admit, and the slug names an action CTX\-08's public view leaves out\. A credential holding a staff grant that reaches this read is answered a page the plane composes from the contract: the catalog row's summary and `reference` member, and the action's `payload:<action>` entry\. That page is the action's reference page wherever a statement names one, generated or not, and the rest of those paragraphs read it as any page, its manifest headings empty\.

That answer comes ahead of the manifest, so it holds while a served manifest still lists the route\. Any other caller naming such a page is answered as a route the manifest does not list, and a slug naming no such row is read as any route is\. The read names an enumeration row and reads no path built from the caller's string\.

CTX\-09: A search\_documentation call \(CTX\-10\) answers sections, never whole pages\. A section is a page's text from a heading of depth 2 or deeper, outside a fenced code block, to the next heading of depth 2 or deeper, so a page's sections partition it and a heading's section holds its lead alone\. The text before the first such heading is the lead section\.

The headings and offsets are the `headings` member's \(CTX\-07\), each with its depth, before that member's fall to depth 2\. A section's anchor is taken by position from the manifest's entries of depth 2 or deeper \(PLD\-L0\-69; tzdoc:TZD\-L0\-05\)\. The i\-th heading takes the i\-th entry's anchor where the counts agree and every pair's texts are equal, each heading read plain, without its inline code marks, link syntax, and backslash escapes\. Where they differ, the page's sections carry no anchor and their hits link the route alone\.

The query, lower\-cased, is read as a text is\. A text word is a run of letters, digits, and underscores, a hyphen or a dot counting inside the word only between two such characters, so an error name, a tool name, a header name, and a file name each stay one word\. A sentence\-final dot ends the word\. A word listed in `search_stop_words` drops unless the query holds nothing else\. The first `search_word_limit` distinct words after the drop are searched and the rest ignored\. A word of `search_prefix_length` characters or more matches a text word that begins with it; a shorter word matches a text word whole\. A query that is one rule code \(MCP\-05\), upper case, with or without its parentheses, is answered first a line naming the code and saying what a rule code is, then the sections holding the code\.

Sections are ranked by Okapi BM25, the method tzTrack's issue search ranks by \(system:XIT\-08\), over three fields of each section\. The fields are its page's title, weighted three; its heading line, weighted two; and its body, the rest of its text, weighted one\. A field's count of a query word is the count of its text words the word matches, as the third paragraph reads a match\. A match on a line of a fenced code block, its fence lines included, counts one half, since a code sample repeats names that say less about a section than its prose\. A field's length is its words for the title and the heading, and the section's code points for the body\. BM25's k1 and b are `search_bm25_k1` and `search_bm25_b`\.

A word's weight is ln\(\(N \+ 10 − n \+ 0\.5\) / \(n \+ 0\.5\)\), and at least zero\. N is every section of every page searched, and n is the sections holding the word in any field, so a word most sections hold weighs little\. A section's score is its BM25 sum times the share of the query's distinct words it holds in any field, so a section holding every word outranks one holding few\. Where the query is a question, holding a question mark or opening with one of the words what, how, why, which, who, where, when, is, are, does, do, and can, a lead section's score is multiplied by 1\.5\. A page's lead says what the page is for, so it answers such a question first\.

A section is a hit only where its heading or body holds a query word; the title's weight orders the hits\. Hits stand in score order, ties in page order within a page and in manifest order across pages, the trees in the order CTX\-10 states\. Every section of a page whose manifest entry carries `in_full_text` false, the generated reference the whole text excludes, stands after every section of an authored page\. The answer holds at most the call's `limit` hits, `search_match_limit` where it names none, and at most `search_page_limit` sections of one page\.

Each hit's line in the answer's `text` is one Markdown line, `- [title › heading](route#anchor): excerpt`, a lead section's `- [title](route): excerpt`, and a section without an anchor linking the route alone\. The excerpt is the section's line holding the most distinct query words, trimmed, cut on a code\-point boundary at `excerpt_max_length`\. Its heading line, the lead's being the page's `#` title line, front matter, and a fenced block's fence lines are never the excerpt\. Where no other line holds a query word, the excerpt is the first other line holding text, and a section with none links alone\. The six bounds, the two BM25 settings, and CTX\-07's `context_lines` live in `schemas/served_context.json` beside the text limits\.

The pages scanned are every page each readable tree's manifest lists, read from the served version as a `page` read reads them, so a hit's section is the text a page read answers, with no cache keyed by caller or query\. Signed in or signed out, a search reading the same trees meets the same order\.

This paragraph qualifies the third paragraph's prefix rule with plurals\. A query word longer than `search_prefix_length` characters that ends in s is searched without that s, so a plural query word also matches its singular: `files` matches `file` and `files`\. A word of `search_prefix_length` characters or fewer keeps its form\. Two query words that come to one form are searched once\.

CTX\-10: **`search_documentation` searches the documentation and answers the ranked sections as data and as lines a model reads\. It is the one management action that answers a request presenting no credential\.** It is an observe action of platform\_context, recorded and metered by the ordinary dispatcher \(MAPI\-06\) and listed as read\_documentation is\. It takes three members\. `query` is required: 1 to `query_max_length` characters holding at least one text word \(CTX\-09\)\. `tree` is optional: one tree of those the caller may search\. `limit` is optional: a whole number from 1 to 20, `search_match_limit` where absent\. A value outside these is refused 400 `invalid_request`, its detail naming the member\. A refused `tree` is answered with the list of the trees the caller may search, so a gated tree's name is never confirmed to a caller who may not read it\.

With a credential the call searches every tree the account may read \(ACB\-L0\-82\), as read\_documentation reads a tree, or the one `tree` names\. The trees stand in the order cloud, tzteam, tzdocs, tzmesh, then tztrack\. It skips a tree whose manifest or a listed page's copy the served version lacks, and answers 503 `context_unavailable` only where every tree it searches is so\. Its record names the bare marker docs:&lt;tree&gt;:search, or docs::search where no tree is named\. A record never names the query's words, which are the caller's own and are recorded nowhere\.

It answers 200 with `contract_version`, `query`, `trees`, the trees searched, `hits`, best first, and `text`\. Each hit carries `tree`, `title`, `route`, `heading`, null for a lead, `anchor`, null where the section carries none, `excerpt`, and `score`, rounded to four decimal places\. `text` holds the same hits as CTX\-09's Markdown lines, in the same order, after the rule\-code line where the query is one rule code\. It is empty where nothing matches, but for that line\.

On the wire the action answers at its own address, `/api/v1/search_documentation`, and a request presenting no bearer credential also at `/api/v1/actions/search_documentation`, each by POST and by GET, a GET taking the members as query parameters\. It is the one exception to API\-L0\-15's rule that no action serves a request presenting no credential\. The exception stands because the website's search box calls the search signed out, and a GET answer can be cached\. A request presenting no bearer credential, one with no `Authorization` header, an empty one, or another scheme, is answered the signed\-out search\. No browser cookie is read, so every signed\-out caller is answered alike\. Over MCP the action takes a connection's identity as read\_documentation does\.

The signed\-out search searches the trees the product gate leaves open to an anonymous reader under the live invite\-only list \(ACB\-L0\-82; PLD\-L0\-76\)\. It writes no record and sets no cookie, and a GET's answer carries `Cache-Control: public, max-age=60` and `X-Robots-Tag: noindex`\. It reads `query`, `tree`, and `limit`, and `q` in `query`'s place while tzDocs's search box sends that name; a request naming both is refused `invalid_request`, as is any other member\.

The admission gate counts each signed\-out request in the source address's documentation search window, `admission:docs_search:<source>`, 120 a minute, apart from its source window and its page window \(PLD\-L0\-67\)\. Past that bound it is refused 429 `rate_capped` with `Retry-After`\. A signed\-out caller can see only what the site already serves an anonymous reader, and can cause one search of the open trees per admitted request, with nothing written\.

CTX\-08: **A served document names a product by an approved public name, as a served string does \(MCP\-05\), and holds no repository path\.** Being served is what makes a document a public surface \(azure:AZD\-08\)\. Every source the index names, a contract document or a guide, names the product by an approved public name, Turn Zero Cloud or tzCloud, and never by a code name or an internal product name\. Every text file in the closure of a published library entry of any kind does the same\. Those text files include a package's documents, its compiled modules, and the declarations beside them, a system vocabulary's documents, sheets, and code, and the library's own requirements documents \(LC\-04; system:FTR\-L0\-26; system:FTR\-L0\-94; system:FTR\-L0\-101; system:FTR\-L0\-106\)\.

A file of code in a closure is held as a document is, because a consumer's agent learns a package from the comments and declarations of the copy vendored into the consumer's own project\. A font's binary files and an image are not text and are outside this statement\.

A source the index names holds no path into the repository that produced it\. A path to a document the platform serves is written as that document's served title\. A path to a document the platform does not serve is written as a plain description of what that document states\. A path to a test, a script, a source file, a build output, an infrastructure file, an example, or a plan is dropped, because a customer holds none of them\. A wire path, a path in the customer's own project, a path inside a published entry's own closure, and a member of the index itself are not repository paths\.

For a published entry's own documents the no\-path rule is system:FTR\-L0\-93's, a Sources section among them\. A comment in an entry's code holds no repository path on any line, and names a module of the platform by what it is, without an address\. The documentation suite, the served\-surface suite, and the library project's suite hold each served kind to this statement; the identifier half of the public\-name rule is MCP\-05's\.

This paragraph states which actions the public view leaves out\. An enumeration row naming `grant` is staff's own, since no customer can hold such a grant; a staff grant is a `grant` value on an enumeration row\. Another row leaves where its `clients` names `browser_call` alone: only a signed\-in page calls it, with no call for a script, tool or application\. A grant that marks no row, `synthetic_seed_purge` or `feedback_queue` among them, is not a staff grant, so its token reads the public view\. To a connection whose credential holds no staff grant, the anonymous reader's among them, a contract source reads without these actions\. A JSON source loses their rows: the enumeration's, the catalog's tools and listing bounds, the payload file's actions, and a skill any of whose actions is one\. An indexed Markdown source loses each paragraph naming one or its reference route, and nothing else\.

A credential holding a staff grant reads each source whole\. The view derives from the sources and authors no fact \(CTX\-03\), and it qualifies MCP\-05's "verbatim", which holds for that credential\. It is no access boundary: the wire gate is the only one \(MCP\-08\)\.<br>

## Source link destinations

This list covers simple inline Markdown links. It does not resolve reference-style links or bare requirement identifiers. The source below preserves those references.

- route\#anchor — not published as a source in this reference.
- route — not published as a source in this reference.

## Source Markdown

```text
---
document: served_context
prefix: CTX
---

# The Served Context — One Source, Three Forms

## Purpose

This document defines the source for the service-contract forms required by API-L0-09: human documentation, MCP discovery, and the agent-consumable authoring bundle. The indexed Markdown and JSON files remain readable without a running server.

The index is `schemas/served_context.json`. A test in the platform's suite checks that the indexed files exist and that required schemas are included. This document owns the rules; the index lists the files.

The server derives MCP discovery and skills from the catalog and packages the indexed contracts in its authoring bundle. At the site render (the site render script, which the site publish and `npm run site:render` run; PLD-L0-69), the reference generator generates the human reference from those sources alongside the narrative manual, and tzdocs checks and renders the combined corpus. Source reproductions and code-derived registration metadata follow MCP-05 and CTX-03; skills follow CTX-04 and API-L0-10, and action payloads are in `schemas/action_payloads.json`.

Requirements are numbered CTX-nn.

## The source

CTX-01 (decided): The one source is the contract set of this folder: each contract's rules in its requirements document, its enumeration or schema in `schemas/`, and the wire schemas joining at C2. The three served forms are generated from it and authored nowhere else. An entry of the words override file stands beside its source until the entry is removed, and the source stays the fallback and the fold's target (PLD-L0-114). The index at `schemas/served_context.json` names what is served: a contract absent from the index is unserved, an index row naming a file that does not exist is a defect, and a schema on disk the index omits is one. The suite refuses both directions, so the index cannot quietly shrink or the source quietly grow past it.

The library's serving is indexed by the library catalog under `library_catalog.md`'s rules (Q-239), and this statement's guarantee extends to it explicitly. A library entry absent from the catalog is unserved, a catalog row naming what does not exist is a defect, and the suite holds both directions there too.

CTX-02 (decided): Static readability is the floor: every indexed source is plain Markdown or JSON, readable from the repository or any copy of it with no server, no build, and no tool beyond a file reader. That floor is C1's exit made permanent rather than met once. The generated forms add addressing, packaging, and rendering; they add no contract content, and any build-registration metadata follows CTX-03, so a tool that reads the raw source early reads the same truth the served forms deliver later. An entry of the words override file is the one exception, while it stands (PLD-L0-114).

CTX-03 (decided): The three forms derive contract content from the indexed sources: human documentation renders it, discovery descriptions quote it (MCP-05), and the bundle packages it. No form independently authors contract facts. An entry of the words override file that changes a contract fact rather than its wording has its source corrected by a fold in a following landing (PLD-L0-114). Correct a missing or incorrect contract fact in its owning source and regenerate the affected forms; correct a generator defect in the generator.

The human reference may also show registration status derived from the production code for the same build. Label it as build metadata, separate from the contract, and verify that it matches the default runtime dispatcher. Registration does not guarantee access for a particular caller or availability of a configured service; state those limits beside the status. Do not infer registration from the presence of a payload schema. This metadata exception does not permit a second authored capability list or additional contract facts.

CTX-04 (decided): The skills are served beside the bundle under the same rule: the set derives from the enumeration of actions — no hand-kept list — and each skill is generated from the capabilities it drives. A skill naming an action the contract lacks therefore fails generation rather than shipping a recipe for a capability that does not exist.

CTX-05 (decided): Discovery's substance is the index: what a newly connected tool learns exists is what the index serves — the overview first, then the contracts by subject. Discovery therefore requires no prior knowledge of Turn Zero Cloud's vocabulary, because every term a listing uses is defined one indexed read away. The same reads arrive as MCP resources and as the observe tools CTX-07 defines; their catalog, text and visibility share one source.

CTX-06 (decided): The bundle carries the operating disciplines an agent must apply, the schema-evolution discipline first. That discipline comprises schema changes as migration files in the customer's repository, destructive changes flagged as such, the development command set — migrate, reset, seed, status, diff, snapshot — and production changes through the migration action (PLD-L0-56) with the version handshake (SVC-L0-11).

The library-first discipline is the second: before hand-building a capability, the agent lists the library (`read_library`), reads the candidate entry (`read_library` with `entry`), and takes it through the served skill (`add-library-entry`; `update-library` for a newer version) into the project's own folder (API-L0-14; SPM-L0-49). This discipline is the serving half of tzTeam's library-consulting promise (REG-26), followable by an agent connected to this surface alone. Where the agent holds no tzTeam registrar, the skill's kit-free ending is its proof: `read_library` with the vendored folder's manifest rows as `installed` (SPM-L0-49), every taken entry answered `current` (LC-06).

The index names each discipline as a guide entry with the commands it must teach. The served guides now exist and distinguish available commands from planned migration and version-handshake behavior. Evaluation must establish that an agent can successfully follow these guides; the existence of guide text alone does not satisfy that obligation.

CTX-07: Tools-only discovery uses read_context, read_documentation, and search_documentation (CTX-10), observe actions of platform_context recorded and metered by the ordinary dispatcher (MAPI-06). The read_context action with no `id` answers the visible ordered catalog. Its entries are overview, service_contracts, manifest_schema, bundle, each deduplicated indexed source addressed as source:<relative indexed path>, guides as guide:<subject>, live and grant-listable skills as skill:<name>, each listable action's two wire shapes as payload:<action>, and two documentation entries per tree the connection's account may read. A paged skill's parts follow its entry as skill:<name>:<part>, listed under the same grant filter as the skill and read through read_context as any entry is (MCP-06). The plane serves those skill entries, which CTX-04 derives; a `skills:<product>` entry lists the skills a product's own server serves.

An overview:<product> entry, overview:tztrack or overview:tzmesh, is that product's own practices, and not the overview MCP-05 states. It opens with a short header the plane composes. The header says that the practices name the product's tools bare and that each is called through this connection with the product's prefix. For tzTrack it also names the acts that run here under the plane's own rows, and the neighbour MCP-13 names. For tzMesh it also says to pass `as`, the participant's id `register` answers, on every later call that takes it, since the door session the connection reaches tzMesh through may be opened afresh (MCP-14).

Its MCP server's instructions resource follows, relayed whole as the front caches it with the server's list (MCP-14), so the server keeps the one source of its practices. The entry follows the overview where MCP-14 lists the product's rows to the connection, and stands on no other connection's catalog, where a read of it refuses context_not_found. A read where the front holds no text refuses context_unavailable, naming the server's address.

The catalog also lists the `tools` entry, a compact index of the tzCloud tools the connection lists. Its first line says once that a tzCloud tool's longer text, where it has one, is its reference page, which `read_documentation` reads, and gives that page's path with the tool's name in it. Then it holds one line for each of the plane's own rows the connection's tools/list carries, in that order. Each line is the tool's name, a colon and a space, then the opening sentence of its description as MCP-05 reads it. An opening longer than `tool_index_sentence_length` code points keeps its first words, which state the tool's purpose, to the last that fits beside an ellipsis that ends it, and splits no word. A first word that alone runs past the bound is cut on a code-point boundary.

For a wire read, MCP-08 selects the company's origin for this index alone; the skill and payload entries still read no MCP address.

The `tools` entry's last line, on a connection served products whose rows MCP-14 lists, names each such product's own entry, `tools:<product>`. That entry holds a line naming the product and the prefix its rows carry here, then one line for each row MCP-14 forwards from the product's server, in the listing's order. Each such line is the tool's name, a colon and a space, then the whole opening sentence of its description as MCP-05 reads it, cut nowhere, so a reader learns what each of the product's tools is for.

The `tools` entry and each `tools:<product>` entry hold at most `tool_index_max_length` code points on every connection but an operator's, below `text_max_limit`, so one read with `limit` set to `text_max_limit` returns each whole however many products the account holds. An operator's `tools` entry may run past one read and pages by `next_offset`, as any long entry does. No line is left out to meet the bound. The two bounds are set so that one read's answer, on the tools served, stays under 10,000 bytes, for a host that cuts a longer tool output. Both bounds live in schemas/served_context.json beside the text limits. The `tools` entry follows the overview and the overview:<product> entries, the product entries follow it, the `skills:<product>` entries follow them, and each text is served once, with no structured copy beside it.

The catalog lists one `skills:<product>` entry for each product whose rows MCP-14 lists to the connection, from the front's predicate alone, so listing the catalog reads no server. A read of it warms that product for a listing and answers each prompt MCP-14 lists from the product's server, under its prefixed name with its description and arguments. Where there is none, it answers one line saying the server serves no skills.

Each such prompt reads as `skill:<prefixed name>`, listed by no catalog page and outside the catalog's stamp. That read warms as a `prompts/get` does, asks the server through the front with no arguments, and answers the server's text, or its refusal in its words, counted as a forward (MCP-14). A client that renders prompts runs a prompt with arguments itself. On a connection where MCP-14 lists none of the product's rows, both entries refuse context_not_found, and a name the front does not list refuses the same. A skill's read whose server does not answer, and a read of either entry whose warmed view holds no list for the product, refuse context_unavailable, naming the server's address.

A payload:<action> entry is one JSON document holding the contract version, the shared shapes that action's request and response reference, and the request and response, derived from schemas/action_payloads.json and hand-kept nowhere. A client therefore reads one action's shapes in one page at the configured maximum limit where they fit, and in two where they do not, instead of paging the whole file, the whole-file source row standing beside them. An entry whose shapes run past two pages is paged as any long JSON entry is.

The documentation entries are docs:<tree> for each tree's index and docs:<tree>:full for its whole text, the tree one of cloud, tzteam, tzdocs, tzmesh, and tztrack (PLD-L0-69). A gated tree's two are listed to a holder of its product profile alone, the predicate ACB-L0-82 owns. Each documentation entry names read_documentation, its tree, its part, and its authentication requirement. The read_context action accepts an exact catalog content identifier, never an arbitrary path or URL, and beside the catalog's identifiers the `manifest_schema` member identifiers the next paragraph states and each `skill:<prefixed name>` the connection is relayed. The read_documentation action accepts only those five tree names and, beside a name, or in its place where a `page` route names the tree, four optional members: `part`, `page`, `query`, and `section`. `section` and `query` beside `page` narrow the page read's answer to one section or to the page's matching lines.

Through the rename's window the tzteam tree's earlier name, blueprint, is read as it where a call names a tree: in `tree`, as a `page` route's first segment, the route then read under the tree's base path, and in the `docs://blueprint/` resources (PLD-L0-69).

The `manifest_schema` entry's summary names its member identifiers: `manifest_schema:<member>` for each top-level member of the schema's `properties`, and `manifest_schema:services:<kind>` for each kind a `oneOf` branch of the `services` member admits, composed from every branch whose `kind` admits it. A kind's own branches, whose `kind` is a const, come first and the shared ones after, each group in schema order, so a first chunk shows the kind's own shape. Each answers the fragment as its own JSON text with the `$defs` it references, paged and stamped as any JSON entry is, listed by no catalog page and outside the catalog's stamp. Where exactly one member has a part, split at its colons and underscores, that is an unknown identifier's last colon-separated part, compared without case, alone or less a trailing s, the read answers that member, its `id` naming it. Any other unknown member refuses context_not_found naming the members.

This paragraph qualifies the sentence above on an unknown member's likely member. One alias counts as a member's part, compared as its parts are: `secret` for `settings`, which binds a stored secret (MAN-14). That read's answer also carries `note`, a sentence naming the identifier asked and the member answered, so a caller learns its identifier named no member. A read by a member's own identifier carries no such sentence.

Where the identifier's last part is a property the answered member's shape declares, at its top or in one of its alternatives, the note adds one sentence saying so. So `manifest_schema:schedules` is told that `schedules` is a property inside `manifest_schema:services:schedule`, not a member of its own.

The `part` member is `index` (the default), `full`, or `outline`. The outline is the index's page lines in the manifest's order, each followed by one indented line per heading of the page below its title with its anchor. The plane composes the outline from the tree's manifest `docs.json` (PLD-L0-69; tzdoc:TZD-L0-05), the index's own form untouched. The `page` member is a route the tree's manifest lists. It is given as the index prints it with or without its trailing slash, or without the base path with or without the slashes around the rest. The home page's route is the base path or `/`. A `page` read answers that page's Markdown copy from the served version, so the generated reference is read page by page as the index promises.

Where `tree` is absent, read_documentation takes the tree from the first segment of the `page` route when it names one of the five trees, each tree's base path being its name (PLD-L0-69). A `page` value beginning with the estate's public origin, which a completed answer's `page` carries (PLD-L0-85; MCP-12), loses it after the length bound has read the value as given, so that `page` passes in as it is. The call then runs as a call naming that tree runs, so a gated tree and a tree the served version lacks are refused as for a named tree. Its record names the tree read from the route as it names a given one. A call naming neither `tree` nor a `page` whose first segment names a tree refuses invalid_request naming the trees the connection may read, its record naming no tree, the bare page marker where a `page` was given.

A call carrying a `query` not read as left out and no `page` is refused as the next paragraph but one states, ahead of the tree, so one naming no tree meets that refusal and not the one before. Its record names docs::search, the tree's place empty, where it names no tree, and docs:<tree>:search where it names one.

The `query` member is a few words, read as CTX-09 reads them. The query is at most `query_max_length` characters, and a query within that bound that holds no word, empty or whitespace alone, is read as if the call had left `query` out.

A `query` without `page` is refused `invalid_request` ahead of the identity, the tree and the excluded pairs, the refusal naming search_documentation (CTX-10), which searches the documentation.

Beside `page`, `section` names one section by the manifest's anchor or by a heading's plain text, a text two headings share resolving to the first in page order, and the read answers that section alone. Where none matches exactly, the value names the first section in page order whose anchor or heading text matches it with both lower-cased, a leading `#` dropped, each run of characters other than letters and digits one hyphen, and outer hyphens trimmed. A `page` value carrying `#` and an anchor is read as that page with `section` set to the anchor, so a hit's link passes in unchanged.

Where the heading has child headings, the answer closes with one line listing the children's anchors, so the reader continues in one call. `section` is bounded as `page` is, and a value matching no heading refuses context_not_found naming `part` `outline` beside the page as the way and as many of the page's anchors as the refusal's budget holds. Rank anchors by how many words of the value they match, most first, with ties in page order. Fold the value and anchors as a section match does, then split them into words. Words match when equal or when one begins with the other and the shorter holds at least three characters. Where a page's sections carry no anchor, the identifier, the refusal, and the children line carry each heading's offset in the anchor's place, the refusal naming the headings and offsets instead of the outline.

Beside `page`, `query` answers the page's lines holding a query word read as CTX-09 reads it, each with `context_lines` lines of context before and after and prefixed by its code-point offset in the page, so a `page` read at that offset continues there. Where that line is a section's first line of text and the two fit within the limit, the read starts at the section's heading. `part` other than the default excludes `page`, `query`, and `section`; `section` requires `page`, excludes `query`, and names the section twice beside a `page` route carrying an anchor; a call naming an excluded pair is refused invalid_request naming the one to drop. A route the manifest does not list refuses context_not_found with the manifest's form in the detail. A served version lacking the manifest or the page refuses context_unavailable.

Every read requires the same identity as the trees' documentation resources (PLD-L0-69). Every read answers under the same paging, stamps, and response shape as the index, the page, the section, and the page's lines each paged within their own text, a bare `page` read's first chunk alone adding `headings`. A signed-in connection naming a gated tree its account may not read is refused as a handler violation, invalid_request, its detail naming the trees that connection may read (ACB-L0-82). The catalog lists two documentation entries per tree and no page, outline, section, or query.

The identifiers are read_documentation's alone, stamped as any text is: docs:<tree>:outline, docs:<tree>:page:<slug>, the slug empty for the home page, docs:<tree>:page:<slug>#<anchor> for a section read, docs:<tree>:page:<slug>:search:<hash> for a page's lines, and docs:<tree>:page:<slug>:outline for a page's outline. The hash is the first sixteen hexadecimal digits of the SHA-256 of the query's lower-cased words as CTX-09 reads them, the stop words among them, joined by one space. A section read's record, a page's lines' record, and a page's outline's record name the page's marker with its route, as a page read's does. The catalog stamp hashes its complete ordered JSON entries; text stamps hash the complete text before paging, with one exception: a `page` read with `query` is stamped with the page's complete text, so its listed offsets and its own continuation carry the page's stamp.

A `page` read's first chunk, where more follows, answers `headings` ahead of `text` where the page holds a heading of depth 2 or deeper outside a fenced code block. Each entry is one such heading's text and the code-point offset where its line starts in the served copy, in the page's order. A page holding more than 40 such headings lists those of depth 2 alone, and answers no `headings` where it holds none of that depth. Each offset is a place where a chunk can start, so a read naming it with that chunk's stamp starts at the heading's line. The continuation names `query` for a passage's words, `headings` for a section where the chunk answers them, and `section` for one section's text; a section read, a page's lines, and a page's outline carry no `headings`. A later chunk, and a page one answer holds whole, carry no `headings`.

A tree's index or outline read that holds less than the whole text closes every chunk's continuation by naming search_documentation for one step's words. A read of `manifest_schema` itself, not one of its members, closes the continuation of each chunk that more follows by naming the member reads.

The `headings` member lists at most `headings_limit` entries, the first in the page's order, counted after the fall to depth 2. Each entry's text holds at most `heading_max_length` code points, a longer text cut on a code-point boundary. Both bounds live in schemas/served_context.json beside the text limits. Where either bound cuts the list, the continuation says the list is cut, in a sentence no longer than the one it replaces, and still names `query`.

Resources, prompts and readers use the same content readers: a fully reconstructed tool result is the same UTF-8 text. Visibility and authorization are recomputed on every call, including continuation; a prior stamp grants no access. The bundle's catalog is the anonymous view's complete source catalog. A tree the served site version lacks (PLD-L0-69), or a missing indexed file, refuses context_unavailable (503), an unknown or unavailable-to-this-view content identifier refuses context_not_found (404), and a changed continuation refuses context_changed (409). Pagination bounds live in schemas/served_context.json: catalog pages have a fixed positive entry limit; text pages have a positive default and maximum measured in Unicode code points. Requests use a safe nonnegative integer offset, default zero, and an optional SHA-256 stamp; text reads may supply an integer limit from one through the configured maximum.

This paragraph qualifies the limit's range above. A read_context or read_documentation call whose `limit` is a larger safe integer reads at the configured maximum, its answer's `note` saying so; read_library with entry refuses it.

The read_documentation, read_context, and read_library with entry actions begin and end a chunk where a reader can stop: a line start outside a fenced code block, a block's opening line, or the line start after its close. A block longer than the limit also holds the last line start within the limit of its opening line and of each such place. A line longer than the limit, or a text with no line end, holds a place at each limit's length from its start.

In a JSON entry, a line start inside a member of the first or second depth shorter than half the limit is no such place. A member runs from the start of the line holding its name to the start of the line after the one holding its value's end. Its depth is the number of braces and brackets open around its name. Where members sharing a line would leave more than the limit between two places, the last line start within the limit of the place before is one. A JSON entry is a read_context entry served as application/json, or a read_library with entry file whose path ends .json and whose content is text, that parses as JSON.

In a text that is not a JSON entry, the line starts after a heading line of depth 2 or deeper outside a fenced code block are no such places, through the start of the first line after it that is not blank. Where that line is itself a heading, its line start stays a place, so every offset `headings` lists starts a chunk. Where that first line opens a fenced code block, the block's opening line is no such place where the heading and the block together fit within the limit, and is one where they do not. Where these places would leave more than the limit between two others, the last line start within the limit of the place before is one, as for a JSON member.

A chunk begins at the last such place at or before the offset asked and ends at the last one within the limit past that offset. Chunks followed by next_offset under one limit hold at most the limit, and chunks asked at every multiple of the limit join with no gap or overlap. Each answer's offset names where its text starts, a chunk asked at another offset re-reading less than one limit before it.

HTTP GET normalizes only canonical unsigned decimal query strings; JSON and MCP use integers. Handler violations refuse invalid_request; MCP schema violations retain the protocol’s own error shape. Offset greater than zero requires a stamp. Any supplied stamp must match the complete current visible catalog or rendered text, hashed as UTF-8; an offset past the end refuses. Responses name stamp, offset, total and next_offset (null at the end), beside entries or id, mime_type and text, with `headings` on a bare `page` read's first chunk alone. A read_context or read_documentation answer holding less than the whole text also names continuation, ahead of text and outside it. It states in words the characters read and either the next offset with the answer's stamp value or that this is the last chunk. IDs are bounded by the configured length and are allowlisted map keys, not input to path resolution.

The `page` value as given is bounded by the same configured length. The identifier a page or a query answers under is the plane's own composition, no input and not re-bounded. The page's copy is read at the path the manifest's matched entry names and never at one built from the caller's string. Records name as their subject the catalog, the exact content ID as asked, or the documentation tree with its part, its page route (the bare marker docs:<tree>:page for a page refused as invalid), or, for a query, the bare marker docs:<tree>:search. A record never names a query's words, which are the caller's own and are recorded nowhere. Records retain the actual credential and application attribution. No personalized global cache or server-held cursor is introduced.

This paragraph qualifies the excluded pairs for two readings. `part` `full` beside `page`, with neither `section` nor `query`, is admitted and reads that page whole, as `page` alone does, under the same identifier and record. So a reader asking for the whole text of one page is answered rather than refused. `part` `outline` beside `page`, with neither `section` nor `query`, is admitted and reads that page's own lines of the outline under its own identifier, an anchor on the route read as the page it names. Its anchors are the manifest's, as the tree's outline's are, on a page whose sections carry none among them. So a reader asking for one page's headings is answered without reading the whole tree's outline.

This statement records a use of MAPI-02's shape clause on list_context's response `tree` and read_documentation's request `tree` in `schemas/action_payloads.json`: each names `tzteam`, the tzTeam tree's name from the product rename, in place of `blueprint`. The request's enum keeps `blueprint` as the earlier name through the rename's window. The platform then held 2 builder accounts that each held a live application, synthetic accounts excluded, read at the change.

This paragraph qualifies the paragraph that states the `page` member, for a page that moved. The tree's manifest lists its moves, each a route a page was read at before and the route of the page it moved to (tzdoc:TZD-L0-05). A `page` naming a move's earlier route, in any form that paragraph admits for a listed route, reads the page it moved to as that page's own route reads it. The answer's `moved_to` then names that page's route. A route the manifest lists as a page is read as that page, never as a move. A move to a route the manifest lists no page at reads nothing and refuses as an unlisted route does.

This paragraph qualifies the sources' rows above for an action the public view leaves out (CTX-08). A `source:` row, the `bundle`, and a `guide:` row read through CTX-08's public view on a connection whose credential holds no staff grant, the anonymous reader's among them. An action whose `clients` names `browser_call` alone has its `payload:<action>` entry listed and read only by a credential holding a staff grant; every other caller reads that identifier as absent.

This paragraph qualifies the `page` paragraphs above. A `page` names a reference page outside the public view where it is `/cloud/reference/actions/<slug>/`, in any form those paragraphs admit, and the slug names an action CTX-08's public view leaves out. A credential holding a staff grant that reaches this read is answered a page the plane composes from the contract: the catalog row's summary and `reference` member, and the action's `payload:<action>` entry. That page is the action's reference page wherever a statement names one, generated or not, and the rest of those paragraphs read it as any page, its manifest headings empty.

That answer comes ahead of the manifest, so it holds while a served manifest still lists the route. Any other caller naming such a page is answered as a route the manifest does not list, and a slug naming no such row is read as any route is. The read names an enumeration row and reads no path built from the caller's string.

CTX-09: A search_documentation call (CTX-10) answers sections, never whole pages. A section is a page's text from a heading of depth 2 or deeper, outside a fenced code block, to the next heading of depth 2 or deeper, so a page's sections partition it and a heading's section holds its lead alone. The text before the first such heading is the lead section.

The headings and offsets are the `headings` member's (CTX-07), each with its depth, before that member's fall to depth 2. A section's anchor is taken by position from the manifest's entries of depth 2 or deeper (PLD-L0-69; tzdoc:TZD-L0-05). The i-th heading takes the i-th entry's anchor where the counts agree and every pair's texts are equal, each heading read plain, without its inline code marks, link syntax, and backslash escapes. Where they differ, the page's sections carry no anchor and their hits link the route alone.

The query, lower-cased, is read as a text is. A text word is a run of letters, digits, and underscores, a hyphen or a dot counting inside the word only between two such characters, so an error name, a tool name, a header name, and a file name each stay one word. A sentence-final dot ends the word. A word listed in `search_stop_words` drops unless the query holds nothing else. The first `search_word_limit` distinct words after the drop are searched and the rest ignored. A word of `search_prefix_length` characters or more matches a text word that begins with it; a shorter word matches a text word whole. A query that is one rule code (MCP-05), upper case, with or without its parentheses, is answered first a line naming the code and saying what a rule code is, then the sections holding the code.

Sections are ranked by Okapi BM25, the method tzTrack's issue search ranks by (system:XIT-08), over three fields of each section. The fields are its page's title, weighted three; its heading line, weighted two; and its body, the rest of its text, weighted one. A field's count of a query word is the count of its text words the word matches, as the third paragraph reads a match. A match on a line of a fenced code block, its fence lines included, counts one half, since a code sample repeats names that say less about a section than its prose. A field's length is its words for the title and the heading, and the section's code points for the body. BM25's k1 and b are `search_bm25_k1` and `search_bm25_b`.

A word's weight is ln((N + 10 − n + 0.5) / (n + 0.5)), and at least zero. N is every section of every page searched, and n is the sections holding the word in any field, so a word most sections hold weighs little. A section's score is its BM25 sum times the share of the query's distinct words it holds in any field, so a section holding every word outranks one holding few. Where the query is a question, holding a question mark or opening with one of the words what, how, why, which, who, where, when, is, are, does, do, and can, a lead section's score is multiplied by 1.5. A page's lead says what the page is for, so it answers such a question first.

A section is a hit only where its heading or body holds a query word; the title's weight orders the hits. Hits stand in score order, ties in page order within a page and in manifest order across pages, the trees in the order CTX-10 states. Every section of a page whose manifest entry carries `in_full_text` false, the generated reference the whole text excludes, stands after every section of an authored page. The answer holds at most the call's `limit` hits, `search_match_limit` where it names none, and at most `search_page_limit` sections of one page.

Each hit's line in the answer's `text` is one Markdown line, `- [title › heading](route#anchor): excerpt`, a lead section's `- [title](route): excerpt`, and a section without an anchor linking the route alone. The excerpt is the section's line holding the most distinct query words, trimmed, cut on a code-point boundary at `excerpt_max_length`. Its heading line, the lead's being the page's `#` title line, front matter, and a fenced block's fence lines are never the excerpt. Where no other line holds a query word, the excerpt is the first other line holding text, and a section with none links alone. The six bounds, the two BM25 settings, and CTX-07's `context_lines` live in `schemas/served_context.json` beside the text limits.

The pages scanned are every page each readable tree's manifest lists, read from the served version as a `page` read reads them, so a hit's section is the text a page read answers, with no cache keyed by caller or query. Signed in or signed out, a search reading the same trees meets the same order.

This paragraph qualifies the third paragraph's prefix rule with plurals. A query word longer than `search_prefix_length` characters that ends in s is searched without that s, so a plural query word also matches its singular: `files` matches `file` and `files`. A word of `search_prefix_length` characters or fewer keeps its form. Two query words that come to one form are searched once.

CTX-10: **`search_documentation` searches the documentation and answers the ranked sections as data and as lines a model reads. It is the one management action that answers a request presenting no credential.** It is an observe action of platform_context, recorded and metered by the ordinary dispatcher (MAPI-06) and listed as read_documentation is. It takes three members. `query` is required: 1 to `query_max_length` characters holding at least one text word (CTX-09). `tree` is optional: one tree of those the caller may search. `limit` is optional: a whole number from 1 to 20, `search_match_limit` where absent. A value outside these is refused 400 `invalid_request`, its detail naming the member. A refused `tree` is answered with the list of the trees the caller may search, so a gated tree's name is never confirmed to a caller who may not read it.

With a credential the call searches every tree the account may read (ACB-L0-82), as read_documentation reads a tree, or the one `tree` names. The trees stand in the order cloud, tzteam, tzdocs, tzmesh, then tztrack. It skips a tree whose manifest or a listed page's copy the served version lacks, and answers 503 `context_unavailable` only where every tree it searches is so. Its record names the bare marker docs:<tree>:search, or docs::search where no tree is named. A record never names the query's words, which are the caller's own and are recorded nowhere.

It answers 200 with `contract_version`, `query`, `trees`, the trees searched, `hits`, best first, and `text`. Each hit carries `tree`, `title`, `route`, `heading`, null for a lead, `anchor`, null where the section carries none, `excerpt`, and `score`, rounded to four decimal places. `text` holds the same hits as CTX-09's Markdown lines, in the same order, after the rule-code line where the query is one rule code. It is empty where nothing matches, but for that line.

On the wire the action answers at its own address, `/api/v1/search_documentation`, and a request presenting no bearer credential also at `/api/v1/actions/search_documentation`, each by POST and by GET, a GET taking the members as query parameters. It is the one exception to API-L0-15's rule that no action serves a request presenting no credential. The exception stands because the website's search box calls the search signed out, and a GET answer can be cached. A request presenting no bearer credential, one with no `Authorization` header, an empty one, or another scheme, is answered the signed-out search. No browser cookie is read, so every signed-out caller is answered alike. Over MCP the action takes a connection's identity as read_documentation does.

The signed-out search searches the trees the product gate leaves open to an anonymous reader under the live invite-only list (ACB-L0-82; PLD-L0-76). It writes no record and sets no cookie, and a GET's answer carries `Cache-Control: public, max-age=60` and `X-Robots-Tag: noindex`. It reads `query`, `tree`, and `limit`, and `q` in `query`'s place while tzDocs's search box sends that name; a request naming both is refused `invalid_request`, as is any other member.

The admission gate counts each signed-out request in the source address's documentation search window, `admission:docs_search:<source>`, 120 a minute, apart from its source window and its page window (PLD-L0-67). Past that bound it is refused 429 `rate_capped` with `Retry-After`. A signed-out caller can see only what the site already serves an anonymous reader, and can cause one search of the open trees per admitted request, with nothing written.

CTX-08: **A served document names a product by an approved public name, as a served string does (MCP-05), and holds no repository path.** Being served is what makes a document a public surface (azure:AZD-08). Every source the index names, a contract document or a guide, names the product by an approved public name, Turn Zero Cloud or tzCloud, and never by a code name or an internal product name. Every text file in the closure of a published library entry of any kind does the same. Those text files include a package's documents, its compiled modules, and the declarations beside them, a system vocabulary's documents, sheets, and code, and the library's own requirements documents (LC-04; system:FTR-L0-26; system:FTR-L0-94; system:FTR-L0-101; system:FTR-L0-106).

A file of code in a closure is held as a document is, because a consumer's agent learns a package from the comments and declarations of the copy vendored into the consumer's own project. A font's binary files and an image are not text and are outside this statement.

A source the index names holds no path into the repository that produced it. A path to a document the platform serves is written as that document's served title. A path to a document the platform does not serve is written as a plain description of what that document states. A path to a test, a script, a source file, a build output, an infrastructure file, an example, or a plan is dropped, because a customer holds none of them. A wire path, a path in the customer's own project, a path inside a published entry's own closure, and a member of the index itself are not repository paths.

For a published entry's own documents the no-path rule is system:FTR-L0-93's, a Sources section among them. A comment in an entry's code holds no repository path on any line, and names a module of the platform by what it is, without an address. The documentation suite, the served-surface suite, and the library project's suite hold each served kind to this statement; the identifier half of the public-name rule is MCP-05's.

This paragraph states which actions the public view leaves out. An enumeration row naming `grant` is staff's own, since no customer can hold such a grant; a staff grant is a `grant` value on an enumeration row. Another row leaves where its `clients` names `browser_call` alone: only a signed-in page calls it, with no call for a script, tool or application. A grant that marks no row, `synthetic_seed_purge` or `feedback_queue` among them, is not a staff grant, so its token reads the public view. To a connection whose credential holds no staff grant, the anonymous reader's among them, a contract source reads without these actions. A JSON source loses their rows: the enumeration's, the catalog's tools and listing bounds, the payload file's actions, and a skill any of whose actions is one. An indexed Markdown source loses each paragraph naming one or its reference route, and nothing else.

A credential holding a staff grant reads each source whole. The view derives from the sources and authors no fact (CTX-03), and it qualifies MCP-05's "verbatim", which holds for that credential. It is no access boundary: the wire gate is the only one (MCP-08).

```
