/**
 * The engine build's capability words — the one home for "this engine does X". A shell gates on a word, never on a
 * version number; the server projects the words it also wires onto its `/v1/capabilities`.
 *
 * A word is added in the release whose code makes it true and is never re-spelt; a word whose behaviour is retired
 * leaves the set in a breaking release. Each word:
 *  - `inherit_env.own_credentials_withheld` — a child spawned on this host never inherits a name the deployment
 *    declared as its own credential (`declareWithheldEnv`): `inheritedHostEnv` subtracts the list from every policy's
 *    result (`"all"` and `"scrub"` alike), and an allow list naming one is refused (`inheritEnvPolicyProblem`; every
 *    spawn throws it). The word speaks of INHERITANCE only: the engine process's own environment stays readable to
 *    same-user processes on the host (`ps -E`), so a credential that never enters it remains the root fix.
 *  - `inherit_env.own_credential_values_withheld` — a child spawned on this host never inherits an env entry whose
 *    value equals a credential value the deployment declared or the engine holds: `declareWithheldEnv` takes one table
 *    `{ names, values }`, the engine adds the credentials it takes in, where it receives them (a first-party brain's
 *    `apiKey` and credential headers, a model entry's credential headers, a protocol peer's credential headers, the
 *    memory distiller's chat seat key), and `inheritedHostEnv` subtracts every entry whose value is one,
 *    compared whole, under every policy. A credential resolved per request (a per-model auth hook's answer) is not in
 *    it: the host that resolves it declares it. The same inheritance-only reading as the word above.
 */
export declare const ENGINE_CAPABILITIES: readonly ["inherit_env.own_credentials_withheld", "inherit_env.own_credential_values_withheld"];
/** One word of {@link ENGINE_CAPABILITIES}. */
export type EngineCapability = (typeof ENGINE_CAPABILITIES)[number];