@dtmd/temper 0.0.4 → 0.0.7

package/dist/src/builtins.js

@@ -1,28 +1,60 @@
 /**
- * The built-in Claude Code kinds — the face nouns a harness author imports
- * (`specs/architecture/15-kinds.md`, "Built-in and custom kinds"). Each is an
+ * The built-in Claude Code kinds — the face nouns a harness author imports.
+ * Each is an
  * ordinary `kind<T>()` value built with the same constructor every provider uses
  * (ownership not privilege). Their five facts are external facts about the Claude
  * Code harness, cited at the point of claim.
  *
  * These are the SDK's own provider-face exports, surfaced through the
- * `@dtmd/temper/claude-code` subpath (`50-distribution.md`, "Decision: one SDK
- * package — the provider face is a subpath export") — never from the root.
+ * `@dtmd/temper/claude-code` subpath
+ * — never from the root.
  */
 import { kind } from "./kind.js";
-import { allowedChars, clause, deny, forbiddenKeys, maxLen, maxLines, minLen, nameMatchesDir, required, } from "./contract.js";
+import { allowedChars, clause, deny, enumOf, forbiddenKeys, maxLen, maxLines, minLen, nameMatchesDir, required, uniqueName, } from "./contract.js";
 /**
  * `skill` — `.claude/skills/<name>/SKILL.md`, a directory unit, YAML frontmatter
- * carrying `name` then `description`; registers a description trigger
+ * 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-02).
+ * 2026-07-07).
  */
 export const skill = kind({
     name: "skill",
     locus: { kind: "at", root: ".claude/skills", glob: "*/SKILL.md" },
     format: "yaml-frontmatter",
     unitShape: "directory",
-    registration: { via: "description-trigger", field: "description" },
+    registration: [{ via: "user-invoked" }, { via: "description-trigger", field: "description" }],
+    identityField: "name",
+});
+/**
+ * `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
+ * `identityField` — like `rule`), the skill's field schema by import, registering
+ * on the same two documented invocation channels as `skill`.
+ */
+export const command = kind({
+    name: "command",
+    locus: { kind: "at", root: ".claude/commands", glob: "*.md" },
+    format: "yaml-frontmatter",
+    unitShape: "file",
+    registration: [{ via: "user-invoked" }, { via: "description-trigger", field: "description" }],
+});
+/**
+ * `agent` — every markdown file under `.claude/agents`, discovered recursively (a
+ * containing subdirectory is purely organizational), YAML frontmatter carrying
+ * `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).
+ */
+export const agent = kind({
+    name: "agent",
+    locus: { kind: "at", root: ".claude/agents", glob: "**/*.md" },
+    format: "yaml-frontmatter",
+    unitShape: "named-field",
+    registration: [{ via: "description-trigger", field: "description" }],
     identityField: "name",
 });
 /**
@@ -35,7 +67,7 @@ export const rule = kind({
     locus: { kind: "at", root: ".claude/rules", glob: "*.md" },
     format: "yaml-frontmatter",
     unitShape: "file",
-    registration: { via: "paths-match", field: "paths" },
+    registration: [{ via: "paths-match", field: "paths" }],
 });
 /**
  * `memory` — a root `<name>.md` (`CLAUDE.md`, `AGENTS.md`), a lone file loaded
@@ -48,14 +80,44 @@ export const memory = kind({
     name: "memory",
     locus: { kind: "at", root: ".", glob: "**/CLAUDE.md" },
     unitShape: "file",
-    registration: { via: "always" },
+    registration: [{ via: "always" }],
 });
 /**
- * The floor for `skill` — Anthropic's documented skill contract: the Agent
+ * `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-10). The first manifest kind
+ * temper ships — the read side of 0021's manifest-authoring surface.
+ */
+export const hook = kind({
+    name: "hook",
+    locus: { kind: "at", root: ".claude", glob: "settings.json" },
+    unitShape: "file",
+    registration: [{ via: "event", field: "event" }],
+    shape: "fields",
+    collectionAddress: { manifest: "settings.json", keyPath: "hooks.<Event>" },
+});
+/**
+ * `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-10). 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 const mcpServer = kind({
+    name: "mcp-server",
+    locus: { kind: "at", root: ".", glob: ".mcp.json" },
+    unitShape: "file",
+    registration: [{ via: "connection" }],
+    shape: "fields",
+    collectionAddress: { manifest: ".mcp.json", keyPath: "mcpServers.*" },
+});
+/**
+ * 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 (`packages/skill.anthropic/PACKAGE.md`,
- * the curated authoring reference this migrates verbatim; `10-contracts.md`,
- * "named for its source"). All sources retrieved 2026-07-01.
+ * validation, and Claude Code's own docs.
+ * All sources retrieved 2026-07-09.
  *
  * Checks the strictest documented profile: the spec and upload validation are
  * hard, Claude Code's runtime is deliberately forgiving ("All fields are
@@ -67,7 +129,7 @@ export const memory = kind({
  * 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 — `10-contracts.md` governs additions): the name
+ * 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."
  *
@@ -78,73 +140,116 @@ export const memory = kind({
  * that is not a command; `metadata` is the sanctioned home for versioning —
  * there is no top-level `version` field.
  */
-export const skillFloor = [
+export const skillDefaultContract = [
     clause(required("name"), {
         severity: "required",
         guidance: "Every skill declares a `name` — the slug the harness binds to. Claude Code alone would default it from the directory name, but a nameless skill is not portable: the spec and Anthropic's upload validation both require it.",
-        cite: "https://agentskills.io/specification#frontmatter (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#frontmatter (retrieved 2026-07-09)",
     }),
     clause(minLen("name", 1), {
         severity: "required",
         guidance: "A present-but-empty name fails the spec's 1-64 character bound.",
-        cite: "https://agentskills.io/specification#name-field (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#name-field (retrieved 2026-07-09)",
     }),
     clause(allowedChars("name", { ranges: ["a-z", "0-9"], chars: "-" }), {
         severity: "required",
         guidance: "Lowercase letters, digits, and hyphens only — `PDF-Processing` is the spec's own counter-example. The charset also keeps XML out of the name, which Anthropic's upload validation separately forbids.",
-        cite: "https://agentskills.io/specification#name-field (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#name-field (retrieved 2026-07-09)",
     }),
     clause(maxLen("name", 64), {
         severity: "required",
         guidance: "Keep the name short and slug-like; it becomes a directory and an id.",
-        cite: "https://agentskills.io/specification#name-field (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#name-field (retrieved 2026-07-09)",
     }),
     clause(deny("name", ["anthropic", "claude"]), {
         severity: "required",
         guidance: "Reserved words, enforced by Anthropic's platform upload validation (not by the open spec, and not by Claude Code's runtime — which itself ships a `claude-api` skill). Keep them out if the skill will ever travel through the API or claude.ai.",
-        cite: "https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview#skill-structure (retrieved 2026-07-01)",
+        cite: "https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview#skill-structure (retrieved 2026-07-09)",
     }),
     clause(nameMatchesDir(), {
         severity: "required",
         guidance: "The spec requires the name to match its parent directory. Claude Code decouples the two (the frontmatter name is a display label; the directory names the slash command, except for a plugin-root SKILL.md) — but a mismatch is a portability trap and a reader trap even where it loads.",
-        cite: "https://agentskills.io/specification#name-field (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#name-field (retrieved 2026-07-09)",
     }),
     clause(required("description"), {
         severity: "required",
         guidance: "The description is how the model chooses this skill from potentially 100+ available — it is the skill's API. Claude Code would fall back to the body's first paragraph; the spec and upload validation require it declared.",
-        cite: "https://agentskills.io/specification#frontmatter (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#frontmatter (retrieved 2026-07-09)",
     }),
     clause(minLen("description", 1), {
         severity: "required",
         guidance: "Say both what the skill does and when to use it, with the keywords a user would naturally say. Write in third person — the text is injected into the system prompt, and inconsistent point-of-view causes discovery problems.",
-        cite: "https://agentskills.io/specification#description-field (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#description-field (retrieved 2026-07-09)",
     }),
     clause(maxLen("description", 1024), {
         severity: "required",
         guidance: "The spec's cap. Claude Code additionally truncates the skill listing at 1,536 combined characters (description + when_to_use) — truncation, not rejection, but text past the fold cannot help the model choose.",
-        cite: "https://agentskills.io/specification#description-field (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#description-field (retrieved 2026-07-09)",
     }),
     clause(maxLen("compatibility", 500), {
         severity: "required",
         guidance: "Optional field; when present the spec caps it at 500 characters. Most skills do not need it.",
-        cite: "https://agentskills.io/specification#frontmatter (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#frontmatter (retrieved 2026-07-09)",
     }),
     clause(maxLines(500), {
         severity: "advisory",
         guidance: "Progressive disclosure: keep SKILL.md under 500 lines and move detailed reference material to separate files, one level deep. Once a skill loads, its body stays in context across turns — every line is a recurring token cost. The context window is a public good.",
-        cite: "https://agentskills.io/specification#progressive-disclosure (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#progressive-disclosure (retrieved 2026-07-09)",
     }),
     clause(forbiddenKeys(["globs", "alwaysApply"]), {
         severity: "required",
         guidance: "Cursor `.mdc` keys. Nothing in the Agent Skills spec or Claude Code's documented frontmatter accepts them — a skill authored with them is carrying dead configuration that another tool's semantics silently fail to apply.",
-        cite: "https://agentskills.io/specification#frontmatter (retrieved 2026-07-01)",
+        cite: "https://agentskills.io/specification#frontmatter (retrieved 2026-07-09)",
     }),
 ];
 /**
- * The floor for `rule` — Anthropic's documented contract for a Claude Code
+ * 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).
+ */
+export const commandDefaultContract = skillDefaultContract.filter((entry) => entry.predicate.key !== "name-matches-dir");
+/**
+ * The default contract for `agent` — Anthropic's documented subagent contract
+ * (code.claude.com/docs/en/sub-agents, retrieved 2026-07-07): `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
+ * loads only one definition.
+ *
+ * Deliberately narrow, like `ruleDefaultContract`: undecidable properties (whether the
+ * description triggers well, model/permissionMode's semi-open vocabularies) stay
+ * out of the gate — the format documents little else that is decidable.
+ */
+export const agentDefaultContract = [
+    clause(required("name"), {
+        severity: "required",
+        guidance: "Every subagent declares a `name` — its unique identifier. Claude Code binds identity to this field alone, never the filename, so a nameless subagent cannot be delegated to.",
+        cite: "https://code.claude.com/docs/en/sub-agents (retrieved 2026-07-07)",
+    }),
+    clause(allowedChars("name", { ranges: ["a-z"], chars: "-" }), {
+        severity: "required",
+        guidance: "Lowercase letters and hyphens only — no digits, unlike a skill's `[a-z0-9-]` name. Hooks receive this value as `agent_type`.",
+        cite: "https://code.claude.com/docs/en/sub-agents (retrieved 2026-07-07)",
+    }),
+    clause(uniqueName(), {
+        severity: "required",
+        guidance: "Keep `name` values unique across the whole tree — when two files in one scope declare the same name, Claude Code loads only one of them, silently shadowing the other.",
+        cite: "https://code.claude.com/docs/en/sub-agents (retrieved 2026-07-07)",
+    }),
+    clause(required("description"), {
+        severity: "required",
+        guidance: "The description is how Claude decides when to delegate to this subagent — write it so the trigger is unambiguous.",
+        cite: "https://code.claude.com/docs/en/sub-agents (retrieved 2026-07-07)",
+    }),
+];
+/**
+ * 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-01.
+ * reference this migrates verbatim). All sources retrieved 2026-07-09.
  *
  * `paths` is the one documented frontmatter key for rules: glob patterns
  * (brace expansion supported) that scope the rule to matching files. Rules
@@ -152,9 +257,9 @@ export const skillFloor = [
  * rules load when Claude reads a matching file. Note skills now take a
  * `paths` key too — the two schemas are separate. (Guidance only: an
  * optional field asserts nothing decidable, so it carries no clause of its
- * own — `10-contracts.md`, "Judged at the node scope": `required` is the one
+ * 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-01)
+ * https://code.claude.com/docs/en/memory#path-specific-rules (retrieved 2026-07-09)
  *
  * 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
@@ -166,29 +271,28 @@ export const skillFloor = [
  * behavior drifts, and test a change by watching whether Claude's behavior
  * actually shifts.
  */
-export const ruleFloor = [
+export const ruleDefaultContract = [
     clause(forbiddenKeys(["description", "globs", "alwaysApply"]), {
         severity: "required",
         guidance: "Cursor `.mdc` keys. Claude Code's documented rules schema is `paths`-only; a rule authored with Cursor frontmatter is configuration another tool's semantics silently fail to honor — the rule loads, the scoping you meant does not. (That Claude Code ignores unknown keys is observed behavior, not documented contract — the documented schema is the citation.)",
-        cite: "https://code.claude.com/docs/en/memory#path-specific-rules (retrieved 2026-07-01)",
+        cite: "https://code.claude.com/docs/en/memory#path-specific-rules (retrieved 2026-07-09)",
     }),
     clause(maxLines(200), {
         severity: "advisory",
         guidance: "Unconditional rules are always-on context, paid every session: the docs' size target is under 200 lines per memory file — 'longer files consume more context and reduce adherence.' (Distinct from the hard 200-line/25KB cutoff, which applies only to auto-memory MEMORY.md; rules load in full regardless of length.) For each line ask: would removing it cause Claude to make mistakes? If not, cut it.",
-        cite: "https://code.claude.com/docs/en/memory#write-effective-instructions (retrieved 2026-07-01)",
+        cite: "https://code.claude.com/docs/en/memory#write-effective-instructions (retrieved 2026-07-09)",
     }),
 ];
 /**
- * The floor for the qualified `claude-code.memory` kind — Anthropic's
+ * 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-02.
+ * the curated authoring reference this migrates verbatim). Retrieved 2026-07-09.
  *
  * 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-02), so there is no
+ * (code.claude.com/docs/en/memory, retrieved 2026-07-09), 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 (`specs/intent/00-intent.md`,
- * law 3: decidable clauses only). The single clause is a context-cost
+ * 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.
  *
  * What the clauses cannot carry, as guidance: a `paths:` frontmatter block
@@ -206,29 +310,129 @@ export const ruleFloor = [
  * directory, not below it. Personal, un-shared notes go in `CLAUDE.local.md`
  * (gitignored), appended after `CLAUDE.md` at its level.
  */
-export const memoryAnthropicFloor = [
+export const memoryAnthropicDefaultContract = [
     clause(maxLines(200), {
         severity: "advisory",
         guidance: "CLAUDE.md is always-on context, paid every session. The memory docs' size target is under 200 lines per memory file — 'longer files consume more context and reduce adherence.' For each line ask: would removing it cause Claude to make mistakes? If not, cut it. (Advisory: Claude Code loads the file in full regardless of length; this is a context-cost budget, not a hard cutoff.)",
-        cite: "https://code.claude.com/docs/en/memory#write-effective-instructions (retrieved 2026-07-02)",
+        cite: "https://code.claude.com/docs/en/memory#write-effective-instructions (retrieved 2026-07-09)",
     }),
 ];
 /**
- * The floor for the qualified `agents-md.memory` kind — the AGENTS.md
+ * 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-02); the format deliberately
- * constrains nothing. A floor that manufactured a required field, a size
+ * 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 (`specs/intent/00-intent.md`, law 3). Even the tempting size
+ * 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); Codex concatenates the
- * chain root-to-cwd and stops once combined size hits a byte budget, not a
- * per-file line count; Gemini CLI reads `GEMINI.md` by default and only
- * treats `AGENTS.md` as an alias when configured; Claude Code does not read
- * `AGENTS.md` natively — bridge it with a `CLAUDE.md` that
- * `@AGENTS.md`-imports it. All retrieved 2026-07-02.
- */
-export const memoryAgentsMdFloor = [];
+ * `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 const memoryAgentsMdDefaultContract = [];
+/**
+ * Every documented Claude Code hook lifecycle event — the closed set a `hooks.<Event>`
+ * key is drawn from (code.claude.com/docs/en/hooks, "Hook events", retrieved 2026-07-10).
+ * The allowlist the `hook` default contract's one decidable clause ranges over; the
+ * update ritual when the docs add an event is to re-fetch and extend this set, never to
+ * re-derive from memory.
+ */
+const DOCUMENTED_HOOK_EVENTS = [
+    "SessionStart",
+    "Setup",
+    "UserPromptSubmit",
+    "UserPromptExpansion",
+    "PreToolUse",
+    "PermissionRequest",
+    "PermissionDenied",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PostToolBatch",
+    "Notification",
+    "MessageDisplay",
+    "SubagentStart",
+    "SubagentStop",
+    "TaskCreated",
+    "TaskCompleted",
+    "Stop",
+    "StopFailure",
+    "TeammateIdle",
+    "InstructionsLoaded",
+    "ConfigChange",
+    "CwdChanged",
+    "FileChanged",
+    "WorktreeCreate",
+    "WorktreeRemove",
+    "PreCompact",
+    "PostCompact",
+    "Elicitation",
+    "ElicitationResult",
+    "SessionEnd",
+];
+/**
+ * The default contract for `hook` — Anthropic's documented hooks contract
+ * (code.claude.com/docs/en/hooks, retrieved 2026-07-10). 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.
+ *
+ * Deliberately absent — 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, which the collection address does not walk into; a clause over it
+ * would range over a field the read never surfaces, so it is no clause at all. 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 const hookDefaultContract = [
+    clause(enumOf("event", DOCUMENTED_HOOK_EVENTS), {
+        severity: "required",
+        guidance: "A hook keys under its lifecycle event; an event outside the documented set is dead configuration — Claude Code silently never fires a hook under an unrecognized event. If this is a newly-documented event, re-fetch code.claude.com/docs/en/hooks and extend temper's cited set rather than working around the finding.",
+        cite: "https://code.claude.com/docs/en/hooks (retrieved 2026-07-10)",
+    }),
+];
+/**
+ * Every documented `.mcp.json` server transport — the closed set a server entry's `type`
+ * is drawn from (code.claude.com/docs/en/mcp, retrieved 2026-07-10). `stdio` is the
+ * default when `type` is absent; `streamable-http` is the MCP spec's own name for `http`,
+ * accepted as an alias so configurations copied from server docs work unchanged; `sse` is
+ * documented but deprecated; `ws` is the WebSocket transport. The update ritual when the
+ * docs add a transport is to re-fetch and extend this set, never to re-derive from memory.
+ */
+const DOCUMENTED_MCP_TRANSPORTS = ["stdio", "http", "streamable-http", "sse", "ws"];
+/**
+ * The default contract for `mcpServer` — Anthropic's documented `.mcp.json` contract
+ * (code.claude.com/docs/en/mcp, retrieved 2026-07-10). 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.
+ *
+ * Deliberately absent — the per-transport requirements are conditional on `type`, which no
+ * single-field clause can decide: a `url` with no `type` is a configuration error (Claude
+ * Code reads it as a stdio server and skips it), a stdio server needs a `command`, and a
+ * remote server needs a `url` — each a two-field implication the closed predicate
+ * vocabulary cannot express, so it rides guidance rather than a clause that would range
+ * over a field the shape of the check cannot see.
+ */
+export const mcpServerDefaultContract = [
+    clause(enumOf("type", DOCUMENTED_MCP_TRANSPORTS), {
+        severity: "required",
+        guidance: "A server's `type` names its transport; a value outside the documented set is one Claude Code cannot honor. Absent reads as `stdio` — but an entry that carries a `url` with no `type` is then a configuration error, because Claude Code treats it as a stdio server and skips it: add `type: \"http\"` (or `sse`/`ws`). A stdio server needs a `command`; a remote server needs a `url`. If this is a newly-documented transport, re-fetch code.claude.com/docs/en/mcp and extend temper's cited set rather than working around the finding.",
+        cite: "https://code.claude.com/docs/en/mcp (retrieved 2026-07-10)",
+    }),
+];

package/dist/src/claude-code.d.ts

@@ -1,15 +1,13 @@
 /**
  * The `@dtmd/temper/claude-code` subpath — the first-party Claude Code
- * provider face (`specs/architecture/50-distribution.md`, "Decision: one SDK
- * package — the provider face is a subpath export"). A harness author who
+ * provider face. A harness author who
  * targets Claude Code imports the built-in kinds from here, never the root:
- * the root carries only the six-noun core, and identity travels by import
- * (`specs/architecture/15-kinds.md`), so a subpath specifier is a full module
- * specifier like any other. The built-in floors (exported clause arrays,
- * `10-contracts.md`, "A shared clause set — a floor") join the kinds here
- * too: adoption is `import { skill, skillFloor } from "@dtmd/temper/claude-code"`.
+ * the root carries only the six-noun core, and identity travels by import,
+ * so a subpath specifier is a full module
+ * specifier like any other. The built-in default contracts join the kinds here
+ * too: adoption is `import { skill, skillDefaultContract } from "@dtmd/temper/claude-code"`.
  */
-export type { Memory, Rule, Skill } from "./builtins.js";
-export { memory, memoryAgentsMdFloor, memoryAnthropicFloor, rule, ruleFloor, skill, skillFloor } from "./builtins.js";
+export type { Agent, Hook, McpServer, Memory, Rule, Skill } from "./builtins.js";
+export { agent, agentDefaultContract, command, commandDefaultContract, hook, hookDefaultContract, mcpServer, mcpServerDefaultContract, memory, memoryAgentsMdDefaultContract, memoryAnthropicDefaultContract, rule, ruleDefaultContract, skill, skillDefaultContract, } from "./builtins.js";
 export type { Blocks, File, Prose, Text } from "./prose.js";
 export { blocks, file, text } from "./prose.js";

package/dist/src/claude-code.js

@@ -1,13 +1,11 @@
 /**
  * The `@dtmd/temper/claude-code` subpath — the first-party Claude Code
- * provider face (`specs/architecture/50-distribution.md`, "Decision: one SDK
- * package — the provider face is a subpath export"). A harness author who
+ * provider face. A harness author who
  * targets Claude Code imports the built-in kinds from here, never the root:
- * the root carries only the six-noun core, and identity travels by import
- * (`specs/architecture/15-kinds.md`), so a subpath specifier is a full module
- * specifier like any other. The built-in floors (exported clause arrays,
- * `10-contracts.md`, "A shared clause set — a floor") join the kinds here
- * too: adoption is `import { skill, skillFloor } from "@dtmd/temper/claude-code"`.
+ * the root carries only the six-noun core, and identity travels by import,
+ * so a subpath specifier is a full module
+ * specifier like any other. The built-in default contracts join the kinds here
+ * too: adoption is `import { skill, skillDefaultContract } from "@dtmd/temper/claude-code"`.
  */
-export { memory, memoryAgentsMdFloor, memoryAnthropicFloor, rule, ruleFloor, skill, skillFloor } from "./builtins.js";
+export { agent, agentDefaultContract, command, commandDefaultContract, hook, hookDefaultContract, mcpServer, mcpServerDefaultContract, memory, memoryAgentsMdDefaultContract, memoryAnthropicDefaultContract, rule, ruleDefaultContract, skill, skillDefaultContract, } from "./builtins.js";
 export { blocks, file, text } from "./prose.js";

package/dist/src/contract.d.ts

@@ -1,17 +1,16 @@
 /**
- * Contracts — clauses and requirements as typed values (`specs/architecture/10-contracts.md`).
+ * Contracts — clauses and requirements as typed values.
  * A clause is `predicate · severity · guidance · cite`; a requirement is
- * `means · kind · required · clauses? · verifiedBy?`. Both erase to compiled data
- * at the seam (`20-surface.md`): the author composes typed objects, the engine
+ * `prose · kind · required · clauses? · verifiedBy?`. Both erase to compiled data
+ * at the seam: the author composes typed objects, the engine
  * consumes their rows. The predicate vocabulary is the closed algebra — a clause
- * outside it is a squiggle, not a runtime rejection (`10-contracts.md`, the two
- * walls).
+ * outside it is a squiggle, not a runtime rejection.
  */
 import type { KindDefinition } from "./kind.js";
 /** A clause's delivery posture: `required` gate-blocks, `advisory` reports. */
 export type Severity = "required" | "advisory";
 /**
- * A member of the closed predicate algebra (`10-contracts.md`). Both a kind's
+ * A member of the closed predicate algebra. Both a kind's
  * own `expect` clauses and a requirement's `clauses` compile to the row's full
  * `key`/`field`/`severity`/argument shape (`declarations.ts` `clauseRow`): a
  * floor clause's own `bound`/`charset`/`keys`/`values` ride the row alongside
@@ -28,21 +27,29 @@ export interface Predicate {
     readonly args?: Readonly<Record<string, number>>;
     /**
      * `membership`'s target requirement name — a separate slot from `field` (the
-     * checked field) since `membership` names both (`10-contracts.md`, "Judged
-     * at the node-set scope").
+     * checked field) since `membership` names both.
      */
     readonly target?: string;
-    /** `allowed_chars`'s declared character class (`10-contracts.md`, "allowed_chars"). */
+    /** `allowed_chars`'s declared character class. */
     readonly charset?: Charset;
     /** `forbidden_keys`'s forbidden key list. */
     readonly keys?: readonly string[];
     /** `enum`/`deny`'s permitted or forbidden value list. */
     readonly values?: readonly string[];
+    /** `range`'s inclusive numeric bound. */
+    readonly range?: {
+        readonly min: number;
+        readonly max: number;
+    };
+    /** `section_contains`'s heading-text prefix and the marker each governed section must carry. */
+    readonly section?: {
+        readonly heading: string;
+        readonly marker: string;
+    };
 }
 /**
  * The character class `allowed_chars` admits — inclusive ranges plus individual
- * characters, e.g. `[a-z0-9-]` (`10-contracts.md`, "Decision: `allowed_chars`,
- * not a general `pattern` clause"). Each range is a `"<lo>-<hi>"` two-character
+ * characters, e.g. `[a-z0-9-]`. Each range is a `"<lo>-<hi>"` two-character
  * span (`src/contract.rs` `parse_range`'s wire spelling).
  */
 export interface Charset {
@@ -69,6 +76,23 @@ export declare const deny: (field: string, values: readonly string[]) => Predica
 export declare const requireSections: () => Predicate;
 /** The member's name matches its directory. */
 export declare const nameMatchesDir: () => Predicate;
+/** Names are unique within the artifact kind (a scope-wide identity collision). */
+export declare const uniqueName: () => Predicate;
+/**
+ * The named field may be present — always satisfied, recording the key as part of a
+ * declared (closed) schema. `dependency-exists` has no constructor: the engine holds
+ * it back absent a decidable reference syntax, so a hand-authored clause would fail
+ * admissibility.
+ */
+export declare const optional: (field: string) => Predicate;
+/** The field's numeric value lies within the inclusive `[min, max]` bound. */
+export declare const range: (field: string, min: number, max: number) => Predicate;
+/** The field's value is one of `values`. Spelled `enumOf` — `enum` is a reserved word. */
+export declare const enumOf: (field: string, values: readonly string[]) => Predicate;
+/** The named body marker is defined (e.g. `disable-model-invocation`). */
+export declare const mustDefine: (marker: string) => Predicate;
+/** Every body section whose heading *starts with* `heading` carries `marker` in its body. */
+export declare const sectionContains: (heading: string, marker: string) => Predicate;
 /** The satisfier set's size lies in the inclusive `[min, max]` bound. */
 export declare const count: (bounds: {
     min?: number;
@@ -92,7 +116,7 @@ export declare const degree: (bounds: {
 /**
  * A clause — a predicate the author marks with a severity, the just-in-time
  * guidance the predicate cannot encode, and the external-fact `cite` that makes
- * a maintained floor auditable (`10-contracts.md`, "The clause").
+ * a maintained floor auditable.
  */
 export interface Clause {
     readonly predicate: Predicate;
@@ -107,22 +131,21 @@ export declare function clause(predicate: Predicate, opts: {
     cite?: string;
 }): Clause;
 /**
- * A requirement — a named obligation on the harness (`10-contracts.md`,
- * "Requirements"). `means` is the authored intent, carried never interpreted;
- * `kind` constrains what may fill it **by import** (a value, never a string);
- * `required` is the posture declaration; `clauses` are the requirement's own
- * set-/edge-scope demands — ordinary [`Clause`] values whose predicates range
- * over the satisfier set (`count`/`unique`/`membership`) or its graph
- * neighborhood (`degree`), the same four-channel clause as everywhere
- * (`10-contracts.md`, "Decision: set-scope demands are clauses"); `verifiedBy`
- * wires the behavioral remainder.
+ * A requirement — a named obligation on the harness. `prose` is the authored
+ * intent, carried never interpreted; `kind` constrains what may fill it **by
+ * import** (a value, never a string); `required` is the posture declaration;
+ * `clauses` are the requirement's own set-/edge-scope demands — ordinary
+ * [`Clause`] values whose predicates range over the satisfier set
+ * (`count`/`unique`/`membership`) or its graph neighborhood (`degree`), the
+ * same four-channel clause as everywhere; `verifiedBy` wires the behavioral
+ * remainder.
  */
 export interface Requirement {
-    readonly means: string;
-    readonly kind?: KindDefinition<object>;
+    readonly prose: string;
+    readonly kind?: KindDefinition<never>;
     readonly required?: boolean;
     readonly clauses?: readonly Clause[];
     readonly verifiedBy?: string;
 }
-/** An identity helper — types a requirement literal at the keystroke (`40-composition.md`). */
+/** An identity helper — types a requirement literal at the keystroke. */
 export declare function requirement(init: Requirement): Requirement;