@dtmd/temper 0.0.6 → 0.0.8

package/dist/src/builtins.d.ts

@@ -16,38 +16,142 @@ import type { Clause } from "./contract.js";
 export interface Skill {
     /**
       * The description trigger — always in context; the body loads on invocation
-      * (code.claude.com/docs/en/skills, retrieved 2026-07-02).
+      * (code.claude.com/docs/en/skills, retrieved 2026-07-15).
     */
     readonly description: string;
+    /**
+     * Extra trigger context — phrases and example requests appended to
+     * `description` in the skill listing, sharing its 1,536-character cap
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved
+     * 2026-07-15).
+     */
+    readonly when_to_use?: string;
+    /**
+     * Autocomplete hint for the arguments the skill expects, e.g. `[issue-number]`
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly "argument-hint"?: string;
+    /**
+     * Named positional arguments for `$name` substitution in the body — a
+     * space-separated string or a YAML list, mapped to positions in order
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly arguments?: readonly string[] | string;
+    /**
+     * Tools Claude may use without a permission prompt while the skill is active —
+     * a space/comma-separated string or a YAML list; it grants, never restricts
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly "allowed-tools"?: readonly string[] | string;
+    /**
+     * Tools removed from the pool while the skill is active, cleared on your next
+     * message — a space/comma-separated string or a YAML list
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly "disallowed-tools"?: readonly string[] | string;
+    /**
+     * Model for the rest of the turn while the skill is active — a `/model` value
+     * or `inherit`; not saved to settings
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly model?: string;
+    /**
+     * Effort level while the skill is active, overriding the session's; the
+     * available levels depend on the model
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly effort?: "low" | "medium" | "high" | "xhigh" | "max";
+    /**
+     * Set `fork` to run the skill in a forked subagent context, its body the
+     * subagent's prompt
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly context?: "fork";
+    /**
+     * The subagent type a `context: fork` skill runs as — a built-in
+     * (`Explore`/`Plan`/`general-purpose`) or a custom agent; defaults to
+     * `general-purpose`
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly agent?: string;
+    /**
+     * Hooks scoped to this skill's lifecycle, in the hooks configuration format
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly hooks?: Readonly<Record<string, unknown>>;
+    /**
+     * Shell for the skill's `` !`command` `` injections — `bash` (default) or
+     * `powershell`
+     * (code.claude.com/docs/en/skills, "Frontmatter reference", retrieved 2026-07-15).
+     */
+    readonly shell?: "bash" | "powershell";
     /** The optional license field the skill spec carries (agentskills.io/specification). */
     readonly license?: string;
     /**
      * Set `true` to prevent Claude from automatically loading this skill — only
      * the user-invoked channel stays live (code.claude.com/docs/en/skills,
-     * "Control who invokes a skill", retrieved 2026-07-07). Default: `false`.
+     * "Control who invokes a skill", retrieved 2026-07-15). Default: `false`.
      */
     readonly "disable-model-invocation"?: boolean;
     /**
      * Set `false` to hide the skill from the `/` menu — only the
      * description-trigger channel stays live (code.claude.com/docs/en/skills,
-     * "Control who invokes a skill", retrieved 2026-07-07). Default: `true`.
+     * "Control who invokes a skill", retrieved 2026-07-15). Default: `true`.
      */
     readonly "user-invocable"?: boolean;
+    /**
+     * The optional path scope — a channel gate, not a channel of its own. A
+     * present list removes the skill from *every* invocation channel — the `/`
+     * listing, model invocation, and description-trigger invocation — until
+     * Claude reads a file the globs match; an absent one leaves all channels
+     * live. Distinct from a rule's `paths`, which registers the path-match as
+     * the rule's channel: here the field gates the skill's existing channels
+     * rather than being one, so it adds no `paths-match` registration entry
+     * (code.claude.com/docs/en/skills, retrieved 2026-07-15; verified against
+     * 2.1.210).
+     */
+    readonly paths?: readonly string[];
     readonly prose?: Prose;
 }
+/**
+ * A skill's bundled reference document — a supporting file beside its `SKILL.md`,
+ * loaded only when the skill's body points Claude at it. Prose and nothing else:
+ * the documented shape is a markdown file in the skill's directory with no
+ * frontmatter schema of its own (code.claude.com/docs/en/skills, "Add supporting
+ * files", retrieved 2026-07-16).
+ */
+export interface SupportingDoc {
+    readonly prose?: Prose;
+}
+/**
+ * `supporting-doc` — a skill's bundled reference document, at the nested-file locus:
+ * its path composes from its host skill's unit and the host's template pattern, so it
+ * governs no glob of its own. Fields-free and frontmatterless (no `format` — the whole
+ * file is body), identity from the filename, and channel-less: a supporting file reaches
+ * the world only through the skill whose body references it, never on a channel of its
+ * own (code.claude.com/docs/en/skills, "Add supporting files", retrieved 2026-07-16).
+ */
+export declare const supportingDoc: KindDefinition<SupportingDoc>;
 /**
  * `skill` — `.claude/skills/<name>/SKILL.md`, a directory unit, YAML frontmatter
  * carrying `name` then `description`; registers on both documented invocation
  * channels — user-invoked (`/name`) and description-trigger — modulated per
  * member by the `disable-model-invocation`/`user-invocable` fields
  * (code.claude.com/docs/en/skills, agentskills.io/specification, retrieved
- * 2026-07-07).
+ * 2026-07-15).
+ *
+ * Its one template layer names the bundled reference documents a skill's directory
+ * carries: `supporting-doc` children at the directory's own markdown, the documented
+ * placement (`my-skill/reference.md` beside `SKILL.md`; same source, "Add supporting
+ * files"). The pattern claims the markdown subset the prose-only child kind can hold —
+ * a supporting file of another type (the docs' own `scripts/helper.py`) matches nothing
+ * and stays unmodeled rather than mis-typed.
  */
 export declare const skill: KindDefinition<Skill>;
 /**
  * `command` — `.claude/commands/*.md`, the skill surface's legacy file placement
  * (Claude Code merged commands into skills; code.claude.com/docs/en/skills,
- * retrieved 2026-07-07): a lone file (identity from the stem, so no
+ * retrieved 2026-07-15): a lone file (identity from the stem, so no
  * `identityField` — like `rule`), the skill's field schema by import, registering
  * on the same two documented invocation channels as `skill`.
  */
@@ -56,9 +160,88 @@ export declare const command: KindDefinition<Skill>;
 export interface Agent {
     /**
       * When Claude should delegate to this subagent — the sole registration
-      * channel (code.claude.com/docs/en/sub-agents, retrieved 2026-07-07).
+      * channel (code.claude.com/docs/en/sub-agents, retrieved 2026-07-15).
     */
     readonly description: string;
+    /**
+     * Tools the subagent may use; inherits all when omitted — a space/comma-separated
+     * string or a YAML list
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly tools?: readonly string[] | string;
+    /**
+     * Tools denied — removed from the inherited or specified pool
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly disallowedTools?: readonly string[] | string;
+    /**
+     * Model to run as: `sonnet`/`opus`/`haiku`/`fable`, a full model id, or `inherit`
+     * (the default)
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly model?: string;
+    /**
+     * Permission mode the subagent runs under, overriding the inherited one where the
+     * parent mode does not take precedence (`manual` aliases `default`)
+     * (code.claude.com/docs/en/sub-agents, "Permission modes", retrieved 2026-07-15).
+     */
+    readonly permissionMode?: "default" | "acceptEdits" | "auto" | "dontAsk" | "bypassPermissions" | "plan" | "manual";
+    /**
+     * Maximum agentic turns before the subagent stops
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly maxTurns?: number;
+    /**
+     * Skills preloaded into the subagent's context at startup — full content, not just
+     * descriptions
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly skills?: readonly string[] | string;
+    /**
+     * MCP servers available to the subagent — each entry a configured server's name or
+     * an inline `name → config` definition
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly mcpServers?: readonly string[] | Readonly<Record<string, unknown>>;
+    /**
+     * Lifecycle hooks scoped to this subagent
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly hooks?: Readonly<Record<string, unknown>>;
+    /**
+     * Persistent memory scope enabling cross-session learning: `user`, `project`, or
+     * `local`
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly memory?: "user" | "project" | "local";
+    /**
+     * Set `true` to always run this subagent as a background task
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly background?: boolean;
+    /**
+     * Effort level while the subagent is active, overriding the session's; the
+     * available levels depend on the model
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly effort?: "low" | "medium" | "high" | "xhigh" | "max";
+    /**
+     * Set `worktree` to run the subagent in a temporary git worktree — an isolated repo
+     * copy, auto-cleaned when it makes no changes
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly isolation?: "worktree";
+    /**
+     * Display color in the task list and transcript
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly color?: "red" | "blue" | "green" | "yellow" | "purple" | "orange" | "pink" | "cyan";
+    /**
+     * Auto-submitted first user turn when the agent runs as the main session agent (via
+     * `--agent`/the `agent` setting); prepended to any user prompt
+     * (code.claude.com/docs/en/sub-agents, "Supported frontmatter fields", retrieved 2026-07-15).
+     */
+    readonly initialPrompt?: string;
     readonly prose?: Prose;
 }
 /**
@@ -67,14 +250,14 @@ export interface Agent {
  * `name` then `description`; identity is the `name` field (never the filename),
  * the named-field mode; registers on the description-trigger channel only — no
  * user-invoked slash command (code.claude.com/docs/en/sub-agents, retrieved
- * 2026-07-07).
+ * 2026-07-15).
  */
 export declare const agent: KindDefinition<Agent>;
 /** A Claude Code rule — a flat markdown file with an optional `paths` scope. */
 export interface Rule {
     /**
       * The path scope — a present list matching zero files is a dead edge; an absent
-      * one loads unconditionally (code.claude.com/docs/en/memory, retrieved 2026-07-02).
+      * one loads unconditionally (code.claude.com/docs/en/memory, retrieved 2026-07-15).
     */
     readonly paths?: readonly string[];
     readonly prose?: Prose;
@@ -82,7 +265,7 @@ export interface Rule {
 /**
  * `rule` — `.claude/rules/<name>.md`, a lone file (identity from the stem), YAML
  * frontmatter; registers a path scope (code.claude.com/docs/en/memory, retrieved
- * 2026-07-02).
+ * 2026-07-15).
  */
 export declare const rule: KindDefinition<Rule>;
 /** A Claude Code memory file — `CLAUDE.md`, loaded in full at launch, no frontmatter. */
@@ -92,16 +275,522 @@ export interface Memory {
 /**
  * `memory` — a root `<name>.md` (`CLAUDE.md`, `AGENTS.md`), a lone file loaded
  * unconditionally, with **no frontmatter** (code.claude.com/docs/en/memory,
- * retrieved 2026-07-02): the whole file is the body, so the kind declares no
- * `format`. Its discovery locus is any-depth (a `CLAUDE.md` at any directory);
- * a module-carried memory projects the root file.
+ * retrieved 2026-07-15): the whole file is the body, so the kind declares no
+ * `format`. A project `CLAUDE.md` may sit at either `./CLAUDE.md` or
+ * `./.claude/CLAUDE.md` — equal documented locations (same source) — and the
+ * any-depth locus (a `CLAUDE.md` at any directory) covers both; a
+ * module-carried memory projects the root file.
  */
 export declare const memory: KindDefinition<Memory>;
+/**
+ * A Claude Code hook — a fields-only registration member surfacing inside
+ * `settings.json`, keyed under its lifecycle event. It owns no artifact of its own; a
+ * handler names how it fires (`command`/`http`/`mcp_tool`/`prompt`/`agent`) plus the
+ * documented common fields (code.claude.com/docs/en/hooks, retrieved 2026-07-15).
+ * Authoring `hook(...)` builds a member whose typed fields fold into its manifest entry;
+ * emit erases it into a registration write fact (`emit.ts`).
+ */
+export interface Hook {
+    /** The handler kind — how the hook fires when its event matches. */
+    readonly type?: "command" | "http" | "mcp_tool" | "prompt" | "agent";
+    /** The shell command or executable a `command` handler runs. */
+    readonly command?: string;
+    /** Seconds before the handler is canceled. */
+    readonly timeout?: number;
+    /** The tool-name filter a tool-scoped event fires on (`"*"`/`""`/absent = all). */
+    readonly matcher?: string;
+}
+/**
+ * `hook` — a `settings.json` `hooks.<Event>` registration member: a fields-only kind (no
+ * body slot), its members discovered off the `.claude/settings.json` manifest at the
+ * `hooks.<Event>` collection address, keyed by lifecycle event; registers on the `event`
+ * channel (code.claude.com/docs/en/hooks, retrieved 2026-07-15). The first manifest kind
+ * temper ships — the read side of 0021's manifest-authoring surface.
+ */
+export declare const hook: KindDefinition<Hook>;
+/**
+ * A Claude Code MCP server — a fields-only registration member surfacing inside
+ * `.mcp.json`, keyed by name under `mcpServers`. It owns no artifact of its own; its
+ * `type` names the transport (`stdio` default, or `http`/`streamable-http`/`sse`/`ws`),
+ * and each transport reads a different field set — `command`/`args`/`env` for a local
+ * stdio process, `url`/`headers` for a remote connection
+ * (code.claude.com/docs/en/mcp, retrieved 2026-07-15). Authoring `mcpServer(...)` builds a
+ * member whose typed fields fold into its `mcpServers.*` entry; emit erases it into a
+ * registration write fact (`emit.ts`).
+ */
+export interface McpServer {
+    /**
+     * The transport. Absent reads as `stdio`, so an entry that carries a `url` but no
+     * `type` is a configuration error — Claude Code treats it as a stdio server and skips
+     * it. `streamable-http` is an alias for `http`.
+     */
+    readonly type?: "stdio" | "http" | "streamable-http" | "sse" | "ws";
+    /** The executable a stdio server runs. */
+    readonly command?: string;
+    /** The arguments passed to a stdio server's `command`. */
+    readonly args?: readonly string[];
+    /** Environment variables set in a stdio server's process. */
+    readonly env?: Readonly<Record<string, string>>;
+    /** The endpoint a remote (`http`/`sse`/`ws`) server connects to. */
+    readonly url?: string;
+    /** Static headers sent to a remote server. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Milliseconds before a tool call to this server aborts. */
+    readonly timeout?: number;
+}
+/**
+ * `mcpServer` — a `.mcp.json` `mcpServers.*` registration member: a fields-only kind (no
+ * body slot), its members discovered off the `.mcp.json` manifest at the `mcpServers.*`
+ * collection address, keyed by server name; registers on the `connection` channel
+ * (code.claude.com/docs/en/mcp, retrieved 2026-07-15). The second manifest kind temper
+ * ships, and the first whose entries are objects — each server's fields fold into the
+ * member the read surfaces.
+ */
+export declare const mcpServer: KindDefinition<McpServer>;
+/**
+ * A Claude Code installed plugin — a fields-only registration member surfacing inside
+ * `.claude/settings.json`, keyed by its `<plugin>@<marketplace>` identity
+ * (`formatter@my-marketplace`). It owns no artifact of its own, and unlike a hook (array
+ * value) or an MCP server (object value) its entry's value is a bare scalar, so the
+ * member carries exactly one field (code.claude.com/docs/en/plugins-reference, retrieved
+ * 2026-07-16).
+ *
+ * The members a plugin *contributes* — its skills, agents, hooks, MCP servers — live in
+ * the plugin cache, outside the corpus. Their reach is unmodeled and named as such: this
+ * kind types the enablement entry, never the plugin's own surface.
+ */
+export interface InstalledPlugin {
+    /**
+     * Whether the harness loads the plugin. Claude Code writes `true` at install or enable
+     * time; `false` is a plugin left installed but not loaded, and its documented semantics
+     * gate the member off its one channel — the gate rides this field, never a second
+     * registration entry.
+     */
+    readonly enabled: boolean;
+}
+/**
+ * `installedPlugin` — a `settings.json` `enabledPlugins` registration member: a
+ * fields-only kind (no body slot), its members discovered off the `.claude/settings.json`
+ * manifest at the `enabledPlugins.*` collection address, keyed by plugin identity;
+ * registers on the `enablement` channel — the entry's own presence is the registration
+ * (code.claude.com/docs/en/plugins-reference, retrieved 2026-07-16). The third manifest
+ * kind temper ships, and the first whose entries are scalars.
+ */
+export declare const installedPlugin: KindDefinition<InstalledPlugin>;
+/**
+ * The default contract for `installed-plugin` — **deliberately empty**. The format
+ * documents almost no contract, so it earns an almost-empty default: the honest encoding,
+ * not a gap.
+ *
+ * A charset clause on the `<plugin>@<marketplace>` key has nothing decidable to range
+ * over: the key is the member's identity, and the two sources that describe it do not
+ * settle a charset — the plugins-reference documents the identity as
+ * `formatter@my-marketplace` and schemastore's `claude-code-settings.json` constrains its
+ * `enabledPlugins` keys with no `propertyNames` pattern at all (both retrieved
+ * 2026-07-16), so a clause against either spelling would forge findings on valid harnesses.
+ * The marketplace half of the key is not un-typed, though: it is a declared edge to the
+ * `known-marketplace` member it names, resolved on the reference graph rather than by a
+ * contract clause — an enablement naming a marketplace no registration declares is a
+ * dangling-edge finding, never a convention (decision 0039).
+ *
+ * `enabled` needs no `required` clause: the type already holds it, and a member that
+ * omits it projects the `true` Claude Code itself writes.
+ */
+export declare const installedPluginDefaultContract: readonly Clause[];
+/**
+ * A Claude Code known marketplace — the consumer half of the plugin-distribution graph, a
+ * fields-only registration member surfacing inside `.claude/settings.json` under
+ * `extraKnownMarketplaces`, keyed by the marketplace name a user has registered. Distinct
+ * from the publisher-side {@link Marketplace} catalog: that document is a marketplace's own
+ * `.claude-plugin/marketplace.json`, this entry is one consumer's record that they have
+ * added it — two documents, two owners. The product stores the same registry per-user in
+ * `known_marketplaces.json`; `extraKnownMarketplaces` is the committable, project-scoped
+ * spelling temper types (code.claude.com/docs/en/plugin-marketplaces, retrieved 2026-07-17).
+ *
+ * Its value is an object (unlike an installed plugin's bare boolean), so the member folds
+ * the object's fields: where to fetch the marketplace from, and whether the harness keeps it
+ * up to date.
+ */
+export interface KnownMarketplace {
+    /**
+     * Where the harness fetches this marketplace from — the same documented `source` union a
+     * marketplace lists its plugins by ({@link MarketplaceSource}): a `./`-relative path, or an
+     * object naming `github`, `url`, `git-subdir`, or `npm`
+     * (code.claude.com/docs/en/plugin-marketplaces, retrieved 2026-07-17).
+     */
+    readonly source: MarketplaceSource;
+    /**
+     * Whether the harness re-fetches the marketplace catalog on its own. Omitting it leaves the
+     * harness's default in force; the field only pins the choice
+     * (code.claude.com/docs/en/plugin-marketplaces, retrieved 2026-07-17).
+     */
+    readonly autoUpdate?: boolean;
+}
+/**
+ * `knownMarketplace` — a `settings.json` `extraKnownMarketplaces` registration member: a
+ * fields-only kind (no body slot), its members discovered off the `.claude/settings.json`
+ * manifest at the `extraKnownMarketplaces.*` collection address, keyed by marketplace name;
+ * registers on the `registry` channel — the entry's own presence is the registration, and
+ * whether the marketplace it names actually resolves is a fetch-time fact temper cannot
+ * decide, so the channel is never provably dead (code.claude.com/docs/en/plugin-marketplaces,
+ * retrieved 2026-07-17). The fourth registration member temper ships.
+ */
+export declare const knownMarketplace: KindDefinition<KnownMarketplace>;
+/**
+ * The default contract for `known-marketplace` — **deliberately empty**. The format
+ * documents no decidable schema beyond the shape the {@link KnownMarketplace} type already
+ * holds: `source` is the same union {@link Marketplace} carries and reuses its typing,
+ * `autoUpdate` is a bare optional boolean, and the key is the member's identity (a
+ * marketplace name) rather than a declared field a clause could range over. Nothing decidable
+ * survives that the type does not already enforce, so the honest encoding is the empty
+ * contract, not a forged clause — the `installedPluginDefaultContract` precedent.
+ */
+export declare const knownMarketplaceDefaultContract: readonly Clause[];
+/**
+ * A Claude Code plugin manifest — `.claude-plugin/plugin.json`, the pack's identity and
+ * the metadata a marketplace lists it by. The manifest itself is optional (Claude Code
+ * auto-discovers components in their default locations and derives the name from the
+ * directory); once written, `name` is the only field it must carry
+ * (code.claude.com/docs/en/plugins-reference, retrieved 2026-07-16).
+ *
+ * Every other field is optional and typed. The component path fields do not describe the
+ * plugin — they *relocate* its components, adding to or replacing the default scan, so a
+ * wrong type on one is a load error rather than bad metadata (same source).
+ */
+export interface PluginManifest {
+    /**
+     * The pack's unique identifier — kebab-case, no spaces — and the namespace its
+     * components surface under (`plugin-dev:agent-creator`). When a marketplace entry lists
+     * the plugin under a different name, the marketplace entry's name is what `enabledPlugins`
+     * keys and `/plugin` shows.
+     */
+    readonly name: string;
+    /** JSON Schema URL for editor autocomplete; Claude Code ignores it at load time. */
+    readonly $schema?: string;
+    /**
+     * Human-readable name for the `/plugin` picker, falling back to `name`. May carry spaces
+     * and any casing; never used for namespacing or lookup. Requires Claude Code v2.1.143+.
+     */
+    readonly displayName?: string;
+    /**
+     * Semantic version. Setting it pins the plugin to that string, so users see an update
+     * only when it is bumped; omitting it falls back to the git commit SHA, making every
+     * commit a new version. Set in both places, `plugin.json` wins over the marketplace entry.
+     */
+    readonly version?: string;
+    /** Brief explanation of the plugin's purpose. */
+    readonly description?: string;
+    readonly author?: Readonly<{
+        name?: string;
+        email?: string;
+        url?: string;
+    }>;
+    /** Documentation URL. */
+    readonly homepage?: string;
+    /** Source code URL. */
+    readonly repository?: string;
+    /** License identifier (`MIT`, `Apache-2.0`). */
+    readonly license?: string;
+    /** Discovery tags. */
+    readonly keywords?: readonly string[];
+    /**
+     * Whether the plugin starts enabled when the user has not set a state; defaults to
+     * `true`. A `enabledPlugins` entry at any settings scope and a dependency requirement
+     * each take precedence over it, as does the marketplace entry's own copy of the field.
+     * Requires Claude Code v2.1.154+.
+     */
+    readonly defaultEnabled?: boolean;
+    /** Custom skill directories holding `<name>/SKILL.md`; adds to the default `skills/` scan. */
+    readonly skills?: readonly string[] | string;
+    /** Custom flat `.md` skill files or directories; replaces the default `commands/` scan. */
+    readonly commands?: readonly string[] | string;
+    /** Custom agent files; replaces the default `agents/` scan. */
+    readonly agents?: readonly string[] | string;
+    /** Hook config paths, or the hook config inline. */
+    readonly hooks?: readonly string[] | string | Readonly<Record<string, unknown>>;
+    /** MCP config paths, or the server config inline. */
+    readonly mcpServers?: readonly string[] | string | Readonly<Record<string, unknown>>;
+    /** Custom output style files/directories; replaces the default `output-styles/` scan. */
+    readonly outputStyles?: readonly string[] | string;
+    /** Language Server Protocol configs powering code intelligence. */
+    readonly lspServers?: readonly string[] | string | Readonly<Record<string, unknown>>;
+    /**
+     * The components whose manifest schema may still change between releases. Declaring
+     * `themes`/`monitors` at the top level instead still works today, but `claude plugin
+     * validate` warns and a future release will require them here.
+     */
+    readonly experimental?: Readonly<{
+        themes?: readonly string[] | string;
+        monitors?: readonly string[] | string;
+    }>;
+    /** User-configurable values Claude Code prompts for when the plugin is enabled. */
+    readonly userConfig?: Readonly<Record<string, unknown>>;
+    /** Channel declarations for message injection. */
+    readonly channels?: readonly unknown[];
+    /** Other plugins this one requires, optionally with semver constraints. */
+    readonly dependencies?: readonly (string | Readonly<{
+        name: string;
+        version?: string;
+    }>)[];
+}
+/**
+ * `plugin-manifest` — `.claude-plugin/plugin.json`, a whole-file JSON document (never
+ * frontmatter) whose top-level keys are its fields; identity is read from `name`, the
+ * named-field mode, because the file's stem is `plugin` for every manifest ever written.
+ * It owns its file, so it carries no collection address, and it is channel-less: a
+ * manifest carries distribution metadata rather than session content, so it reaches the
+ * model on no channel of its own — what it reaches is the installer
+ * (code.claude.com/docs/en/plugins-reference, retrieved 2026-07-16).
+ */
+export declare const pluginManifest: KindDefinition<PluginManifest>;
+/**
+ * The default contract for `plugin-manifest` — the documented profile of `claude plugin
+ * validate --strict`, which is the portable bar: Claude Code's own runtime is deliberately
+ * forgiving of unrecognized fields, `--strict` is the CI bar that catches them, and where
+ * the two diverge each clause's guidance says so (all facts
+ * code.claude.com/docs/en/plugins-reference, retrieved 2026-07-16).
+ *
+ * The whole profile ships: every documented rule the vocabulary can decide is a clause
+ * below, and nothing decidable is held.
+ *
+ * **Unrecognized top-level fields** — the substance of `--strict` — are the `closedKeys()`
+ * clause at the end, over the `required`/`optional` rows above it: Claude Code ignores a
+ * key it does not recognize so a manifest doubling as a `package.json` still loads, and
+ * `claude plugin validate` warns rather than fails, but `--strict` turns those warnings
+ * into the CI errors this contract is the profile of. The declared key set is the union of
+ * the two documented sources — the reference's own field tables and the published schema
+ * — because a key *either* one recognizes is a key no clause may indict.
+ *
+ * The component-path fields are gated below rather than held: `type` declares a *set* of
+ * lattice kinds, so a field documented `string|array` is checked as the union it is. Each
+ * clause declares the widest union its documentation states — a narrower set would reject
+ * a documented form, which is a false positive no clause may produce, and the strictest
+ * *documented* profile of a union-typed field is the union.
+ *
+ * Deliberately absent as undecidable: whether the `description` reads well, whether
+ * `keywords` aid discovery, whether `name` names the pack aptly.
+ *
+ * Authoring notes the clauses cannot carry: leave `version` unset while iterating, so the
+ * commit SHA drives updates and users are not stranded on a stale pin; set it once the
+ * plugin has a release cycle, and bump it every time — pushing commits without bumping is
+ * a no-op. Reach for `defaultEnabled: false` when the plugin costs money or scope on load.
+ */
+export declare const pluginManifestDefaultContract: readonly Clause[];
+/**
+ * Where a marketplace fetches one listed plugin from — the documented `source` union
+ * (code.claude.com/docs/en/plugin-marketplaces, "Plugin sources", retrieved 2026-07-16).
+ *
+ * A relative-path string is the local form: it must start with `./` and resolves against
+ * the *marketplace root* — the directory containing `.claude-plugin/` — never against
+ * `.claude-plugin/` itself. The object forms carry a `source` discriminator naming the
+ * fetch mechanism.
+ *
+ * On the three git-based forms (`github`, `url`, `git-subdir`), `ref` names a branch or
+ * tag and `sha` an exact commit; when both are set the `sha` is the effective pin.
+ */
+export type MarketplaceSource = string | Readonly<{
+    source: "github";
+    repo: string;
+    ref?: string;
+    sha?: string;
+}> | Readonly<{
+    source: "url";
+    url: string;
+    ref?: string;
+    sha?: string;
+}> | Readonly<{
+    source: "git-subdir";
+    url: string;
+    path: string;
+    ref?: string;
+    sha?: string;
+}> | Readonly<{
+    source: "npm";
+    package: string;
+    version?: string;
+    registry?: string;
+}>;
+/**
+ * One entry in a marketplace's `plugins` array: `name` and `source` are required, and
+ * every field of the plugin manifest schema may be restated here alongside the
+ * marketplace-specific `source`, `category`, `tags`, `strict`, and `relevance`
+ * (code.claude.com/docs/en/plugin-marketplaces, "Plugin entries", retrieved 2026-07-16).
+ */
+export interface MarketplacePlugin extends Omit<PluginManifest, "name"> {
+    /** The public-facing plugin identifier users type: `/plugin install <name>@<market>`. */
+    readonly name: string;
+    /** Where to fetch this plugin from. */
+    readonly source: MarketplaceSource;
+    /** Category for organization in the picker. */
+    readonly category?: string;
+    /** Tags for searchability. */
+    readonly tags?: readonly string[];
+    /**
+     * Whether `plugin.json` is the authority for component definitions (default `true`).
+     */
+    readonly strict?: boolean;
+    /**
+     * Signals telling Claude Code when to suggest this plugin. Takes effect only for
+     * marketplaces an administrator allowlists in managed settings. Requires v2.1.152+.
+     */
+    readonly relevance?: Readonly<Record<string, unknown>>;
+}
+/**
+ * `.claude-plugin/marketplace.json` — the distribution catalog
+ * (code.claude.com/docs/en/plugin-marketplaces, "Marketplace schema", retrieved
+ * 2026-07-16).
+ */
+export interface Marketplace {
+    /**
+     * The marketplace identifier (kebab-case, no spaces), public-facing: users see it when
+     * installing (`/plugin install my-tool@your-marketplace`). Each user registers only one
+     * marketplace per name — adding a second under the same name replaces the first — and
+     * the name is checked against a reserved deny list.
+     */
+    readonly name: string;
+    /** The maintainer: `name` required, `email` optional. */
+    readonly owner: Readonly<{
+        name: string;
+        email?: string;
+    }>;
+    /** The catalog itself — every plugin this marketplace distributes. */
+    readonly plugins: readonly MarketplacePlugin[];
+    /** JSON Schema URL for editor autocomplete. Claude Code ignores it at load time. */
+    readonly $schema?: string;
+    /** Brief marketplace description. */
+    readonly description?: string;
+    /** Marketplace manifest version. */
+    readonly version?: string;
+    /**
+     * `pluginRoot` is a base directory prepended to relative plugin source paths, so
+     * `"source": "formatter"` resolves under it. `description`/`version` are also accepted
+     * here for backward compatibility.
+     */
+    readonly metadata?: Readonly<{
+        pluginRoot?: string;
+        description?: string;
+        version?: string;
+    }>;
+    /**
+     * Other marketplaces whose plugins this marketplace's plugins may depend on. A
+     * dependency on a marketplace absent from this list is blocked at install.
+     */
+    readonly allowCrossMarketplaceDependenciesOn?: readonly string[];
+    /**
+     * Map from a former plugin `name` to its current name, or to `null` if it was removed —
+     * how existing users migrate across a rename. Requires Claude Code v2.1.193 or later.
+     */
+    readonly renames?: Readonly<Record<string, string | null>>;
+}
+/**
+ * `marketplace` — `.claude-plugin/marketplace.json`, a whole-file JSON document whose
+ * top-level keys are its fields; identity from `name`, the named-field mode, because the
+ * stem is `marketplace` for every catalog ever written. Like its `plugin-manifest`
+ * sibling it owns its file (no collection address) and is channel-less: a catalog is read
+ * by the installer, never surfaced to the model
+ * (code.claude.com/docs/en/plugin-marketplaces, retrieved 2026-07-16).
+ */
+export declare const marketplace: KindDefinition<Marketplace>;
+/**
+ * The default contract for `marketplace` — the strictest documented profile of the catalog
+ * format (all facts code.claude.com/docs/en/plugin-marketplaces, retrieved 2026-07-16).
+ *
+ * The reserved-names clause is the load-bearing one, and it gates a *loud* failure: Claude
+ * Code re-checks reserved names on every load, not only on `/plugin marketplace add`, so a
+ * catalog published under a name that later becomes reserved stops loading for every user
+ * who already added it. That is the one clause here worth more than a lint.
+ *
+ * The `source` union's per-form required fields are now gated via `when` clauses: decision
+ * 0041's Rust implementation shipped in src/contract.rs (Predicate::When, src/engine.rs:1207
+ * decide logic), and the SDK's `when()` export has been available since 884a704 — both well
+ * before these comments were last touched. The per-source-form requirements now hold via guarded
+ * clauses at `plugins[*].source`: the string form needs `leading-dot-slash` shape; each object
+ * form (`github`, `url`, `git-subdir`, `npm`) needs its required fields.
+ *
+ * Deliberately absent as undecidable, and never a clause (`specs/intent.md`, invariant 2):
+ * the docs *also* block names that "impersonate official marketplaces" (`official-claude-plugins`,
+ * `anthropic-plugins-v2` are the page's own examples). Impersonation is semantic judgment —
+ * there is no predicate that decides it, and a clause that guessed would fire on true
+ * negatives. The enumerated deny list is the decidable subset; the impersonation rule rides
+ * as guidance below.
+ *
+ * Authoring notes the clauses cannot carry: a relative-path `source` resolves against a
+ * *local copy* of the marketplace, so it silently fails to resolve for users who added the
+ * marketplace by direct URL to `marketplace.json` — only that one file is downloaded. Reach
+ * for `github`, `url`, or `npm` when the catalog is distributed by URL. Where a git source
+ * pins both `ref` and `sha`, the `sha` is the effective pin. A marketplace entry's
+ * `defaultEnabled` beats the same field in the plugin's own `plugin.json`, while `version`
+ * runs the other way — `plugin.json` wins.
+ */
+export declare const marketplaceDefaultContract: readonly Clause[];
+/**
+ * A Claude Code local settings overlay — `.claude/settings.local.json`, the machine's own
+ * per-project settings at the **local** scope: personal overrides not checked in. Claude
+ * Code gitignores the file when it creates it, and one written by hand belongs in
+ * `.gitignore` too (code.claude.com/docs/en/settings, "Settings files", retrieved
+ * 2026-07-16).
+ *
+ * Only the documented top-level keys a local overlay commonly carries are typed here; the
+ * settings schema is large and version-evolving, and every key not named below survives as
+ * opaque residue named as such — the partial-governance posture 0036 settles. This is
+ * *fields*, not members: a hook registered under `hooks` or a plugin enablement under
+ * `enabledPlugins` here stays part of that field's opaque value, never a modeled `hook`/
+ * `installed-plugin` member of its own (those kinds read the committed `settings.json`,
+ * not this uncommitted overlay).
+ */
+export interface SettingsLocal {
+    /** JSON Schema URL for editor autocomplete; Claude Code ignores it at load time. */
+    readonly $schema?: string;
+    /** Tool-permission rules: `{ allow, ask, deny }`, each an array of rule strings. */
+    readonly permissions?: Readonly<Record<string, unknown>>;
+    /** Environment variables applied to every session, a map of string to string. */
+    readonly env?: Readonly<Record<string, string>>;
+    /** Event hook handlers, keyed by lifecycle event — the hooks-configuration object. */
+    readonly hooks?: Readonly<Record<string, unknown>>;
+    /** The model this project runs as. */
+    readonly model?: string;
+    /** Whether project MCP servers from `.mcp.json` are auto-approved. */
+    readonly enableAllProjectMcpServers?: boolean;
+    /** MCP servers from `.mcp.json` to approve. */
+    readonly enabledMcpjsonServers?: readonly string[];
+    /** MCP servers from `.mcp.json` to reject. */
+    readonly disabledMcpjsonServers?: readonly string[];
+    /** Whether to add a Claude co-author trailer to git commits. */
+    readonly includeCoAuthoredBy?: boolean;
+    /** The output rendering style. */
+    readonly outputStyle?: string;
+}
+/**
+ * `settings-local` — `.claude/settings.local.json`, a whole-file JSON document at the
+ * **local** commitment class: read in place at check and gated, never an `emit` input or
+ * target, its rows derived at read time and no row of it ever landing in the lock. Its
+ * top-level keys are its fields; identity is the fixed singleton stem `settings.local` (the
+ * `file` unit shape — every machine's overlay is the one file at this path, so no declared
+ * key names it). Channel-less: machine configuration read by the harness, never surfaced to
+ * the model (code.claude.com/docs/en/settings, retrieved 2026-07-16; decisions
+ * 0032/0034/0036).
+ */
+export declare const settingsLocal: KindDefinition<SettingsLocal>;
+/**
+ * The default contract for `settings-local` — deliberately near-empty. The settings format
+ * documents a large, version-evolving key set (many keys managed-scope-only, most of them
+ * scalar preferences), so a `closedKeys()` allow-list would strand every valid local
+ * overlay the moment upstream adds a key: 0036 settles the residue *opaque*, not indicted.
+ * What stays decidable is the shape of the few structural container keys a local overlay
+ * carries — `permissions`, `env`, and `hooks` are each a documented JSON *object*, and a
+ * value that is not one cannot be applied — so each is gated as a `map` and everything else
+ * rides opaque. (All facts code.claude.com/docs/en/settings, retrieved 2026-07-16.)
+ *
+ * Deliberately absent as undecidable: whether a permission rule reads correctly, whether an
+ * env var is one this machine needs, whether the chosen `model` exists — semantic judgment,
+ * never a gate clause.
+ */
+export declare const settingsLocalDefaultContract: readonly Clause[];
 /**
  * The default contract for `skill` — Anthropic's documented skill contract: the Agent
  * Skills open standard (agentskills.io), Anthropic's platform upload
  * validation, and Claude Code's own docs.
- * All sources retrieved 2026-07-09.
+ * All sources retrieved 2026-07-15.
  *
  * Checks the strictest documented profile: the spec and upload validation are
  * hard, Claude Code's runtime is deliberately forgiving ("All fields are
@@ -111,11 +800,9 @@ export declare const memory: KindDefinition<Memory>;
  *
  * Deliberately absent — undecidable, so never gate clauses: whether the
  * description actually triggers well or reads third-person (semantic);
- * vagueness/no-op detection (semantic); gerund naming (judgment). Two
- * decidable spec rules are also absent, pending a vocabulary addition (a
- * narrow shape predicate governs additions): the name
- * must not start/end with a hyphen or contain consecutive hyphens; likewise
- * the platform's "no XML tags in the description."
+ * vagueness/no-op detection (semantic); gerund naming (judgment). Nothing
+ * decidable is held: the name's hyphen placement and the platform's "no XML
+ * tags in the description" are the two `shape` clauses below.
  *
  * Authoring notes the clauses cannot carry: prefer gerund or noun-phrase
  * names (`processing-pdfs`, `pdf-processing`) over vague ones (`helper`,
@@ -125,18 +812,35 @@ export declare const memory: KindDefinition<Memory>;
  * there is no top-level `version` field.
  */
 export declare const skillDefaultContract: readonly Clause[];
+/**
+ * The default contract for `supporting-doc` — one clause, because the format documents
+ * exactly one thing about a supporting file that is decidable, and it is not a fact
+ * about the file's own contents: a supporting file is prose Claude reads when the
+ * skill's body points at it, so an unreferenced one is never read at all
+ * (code.claude.com/docs/en/skills, "Add supporting files", retrieved 2026-07-16). The
+ * format carries no frontmatter schema, no required field and no cap of its own, so
+ * nothing else joins it — an almost-empty format gets an almost-empty contract, and
+ * manufacturing a second clause would fake a check the format does not carry.
+ *
+ * The reach bound is a property of the file's *place in the graph*, not its bytes, and
+ * the fact holds of every supporting document — so it is spelled as the by-kind
+ * universal binding at the `each` grain (`model/contract.md`, "selection"), never as a
+ * requirement: a requirement is the opt-in selector, and routing a vendor fact through
+ * one would make the harness's own truth a consumer's ceremony.
+ */
+export declare const supportingDocDefaultContract: readonly Clause[];
 /**
  * The default contract for `command` — `skillDefaultContract`'s clauses minus `nameMatchesDir`: a
  * command is a lone file with no parent directory to match, so the one clause
  * that ranges over the directory relationship does not apply; every other
  * documented skill-schema recommendation, name-requiredness included, still
  * governs a command by the same import (code.claude.com/docs/en/skills,
- * retrieved 2026-07-07).
+ * retrieved 2026-07-15).
  */
 export declare const commandDefaultContract: readonly Clause[];
 /**
  * The default contract for `agent` — Anthropic's documented subagent contract
- * (code.claude.com/docs/en/sub-agents, retrieved 2026-07-07): `name` and
+ * (code.claude.com/docs/en/sub-agents, retrieved 2026-07-15): `name` and
  * `description` are the only required fields, `name` is a "unique identifier
  * using lowercase letters and hyphens" (no digits, unlike a skill's `name`), and
  * "keep `name` values unique across the whole tree" — a same-scope collision
@@ -150,8 +854,7 @@ export declare const agentDefaultContract: readonly Clause[];
 /**
  * The default contract for `rule` — Anthropic's documented contract for a Claude Code
  * rules file, sourced from the memory docs (`.claude/rules/` landed in
- * v2.0.64; `packages/rule.anthropic/PACKAGE.md`, the curated authoring
- * reference this migrates verbatim). All sources retrieved 2026-07-09.
+ * v2.0.64). All sources retrieved 2026-07-15.
  *
  * `paths` is the one documented frontmatter key for rules: glob patterns
  * (brace expansion supported) that scope the rule to matching files. Rules
@@ -161,7 +864,7 @@ export declare const agentDefaultContract: readonly Clause[];
  * optional field asserts nothing decidable, so it carries no clause of its
  * own: `required` is the one
  * presence predicate, and its absence is not itself a predicate.)
- * https://code.claude.com/docs/en/memory#path-specific-rules (retrieved 2026-07-09)
+ * https://code.claude.com/docs/en/memory#path-specific-rules (retrieved 2026-07-15)
  *
  * What the clauses cannot carry, as guidance: keep a rule to facts Claude
  * should hold whenever the rule is in scope — concrete enough to verify ("use
@@ -176,12 +879,11 @@ export declare const agentDefaultContract: readonly Clause[];
 export declare const ruleDefaultContract: readonly Clause[];
 /**
  * The default contract for the qualified `claude-code.memory` kind — Anthropic's
- * documented contract for a project `CLAUDE.md` (`packages/memory.anthropic/PACKAGE.md`,
- * the curated authoring reference this migrates verbatim). Retrieved 2026-07-09.
+ * documented contract for a project `CLAUDE.md`. Retrieved 2026-07-15.
  *
  * Deliberately near-empty, because the format is: `CLAUDE.md` is plain
  * markdown with no documented frontmatter and no required fields
- * (code.claude.com/docs/en/memory, retrieved 2026-07-09), so there is no
+ * (code.claude.com/docs/en/memory, retrieved 2026-07-15), so there is no
  * schema to gate — manufacturing a required field or a forbidden-key list
  * would fake a check the format does not carry. The single clause is a context-cost
  * budget; everything else the contract could say is guidance.
@@ -203,25 +905,40 @@ export declare const ruleDefaultContract: readonly Clause[];
  */
 export declare const memoryAnthropicDefaultContract: readonly Clause[];
 /**
- * The default contract for the qualified `agents-md.memory` kind — the AGENTS.md
- * standard's contract for a memory file, which is that there is almost none
- * (`packages/memory.agents-md/PACKAGE.md`, the curated authoring reference
- * this migrates). Guidance-only, and that is the honest encoding: `AGENTS.md`
- * "is just standard Markdown" with no required fields, no sections, and no
- * frontmatter (agents.md, retrieved 2026-07-09); the format deliberately
- * constrains nothing. A default contract that manufactured a required field, a size
- * gate, or a forbidden-key list would assert a contract the standard
- * disclaims. Even the tempting size
- * number is a *tool's* rule, not the format's: agents read the closest
- * `AGENTS.md` in the tree (nested, nearest-wins; agents.md, retrieved
- * 2026-07-09); Codex concatenates the chain root-to-cwd and stops once
- * combined size hits a byte budget, not a per-file line count
- * (`project_doc_max_bytes`, 32 KiB default;
- * developers.openai.com/codex/guides/agents-md, retrieved 2026-07-09);
- * Gemini CLI reads `GEMINI.md` by default and only treats `AGENTS.md` as an
- * alias when configured via `context.fileName` (geminicli.com/docs/cli/gemini-md,
- * retrieved 2026-07-09); Claude Code does not read `AGENTS.md` natively —
- * bridge it with a `CLAUDE.md` that `@AGENTS.md`-imports it
- * (code.claude.com/docs/en/memory, retrieved 2026-07-09).
- */
-export declare const memoryAgentsMdDefaultContract: readonly Clause[];
+ * The default contract for `hook` — Anthropic's documented hooks contract
+ * (code.claude.com/docs/en/hooks, retrieved 2026-07-15). A hook surfaces at
+ * `hooks.<Event>`, so the member the gate reads is the lifecycle event itself, its name
+ * carried as the `event` field off the collection key. The one decidable, cited property
+ * of that member is its event: a key outside the documented set is dead configuration —
+ * Claude Code silently never fires a hook under an unrecognized event, so the strictest
+ * documented profile is that the event is one temper's cited docs name.
+ *
+ * **Re-examined against decision 0041's widened vocabulary and confirmed to still hold**:
+ * The handler's own schema (`type`/`command`/`url`/`timeout`, the matcher grammar) lives
+ * one array level deeper than `hooks.<Event>`, inside each event's matcher-group list. The
+ * collection address `hooks.<Event>` does not walk into arrays, and even with the guard
+ * vocabulary's when/enumOf/type extensions, addressing still cannot spell a path into the
+ * handler array (e.g., `hooks.<Event>[0].type`). A clause over it would range over a field
+ * the read never surfaces, so it is no clause at all — the addressing-reach gap remains.
+ * What the clauses cannot carry, as guidance: keep a handler's `type` among
+ * `command`/`http`/`mcp_tool`/`prompt`/`agent`; a `command` handler needs a `command`, an
+ * `http` handler a `url`; the `matcher` filters tool-scoped events and is inert on events
+ * that carry no tool (`UserPromptSubmit`, `Stop`, and their siblings).
+ */
+export declare const hookDefaultContract: readonly Clause[];
+/**
+ * The default contract for `mcpServer` — Anthropic's documented `.mcp.json` contract
+ * (code.claude.com/docs/en/mcp, retrieved 2026-07-15). A server surfaces at `mcpServers.*`,
+ * keyed by name, its transport-specific fields folded into the member. The one decidable,
+ * cited property that holds across every transport is `type`: a value outside the
+ * documented set is a transport Claude Code cannot honor, so the strictest documented
+ * profile is that a present `type` names one temper's cited docs carry. An absent `type`
+ * passes — Claude Code reads it as `stdio`, the documented default.
+ *
+ * The per-transport requirements are now gated via `when` clauses: a stdio server (type
+ * absent or `stdio`) needs a `command`, and a remote server (type `http`, `streamable-http`,
+ * `sse`, or `ws`) needs a `url`. Decision 0041's Rust implementation shipped in
+ * src/contract.rs and the SDK's `when()` export has been available since 884a704 — both
+ * well before these comments were last written.
+ */
+export declare const mcpServerDefaultContract: readonly Clause[];