@dtmd/temper 0.0.4 → 0.0.7

package/README.md

@@ -1,8 +1,8 @@
 # temper-sdk — the authoring face
 
 The typed module library the ratified corpus names as temper's authoring
-medium (`specs/intent/00-intent.md`, the SDK Decision; `specs/architecture/20-surface.md`,
-"The seam — one implementation"). A harness author composes members as typed
+medium (`specs/intent.md`; `specs/model/pipeline.md`, "The SDK"). A harness
+author composes members as typed
 values in the **six-noun model**; `emit` compiles the whole into the declaration
 rows the engine reads, a byte-faithful `.claude/**` projection, and the lock. The
 SDK implements **no semantics** — every type erases at the seam, and the engine
@@ -11,14 +11,15 @@ consumes only declared data, offline, no Node.
 ## The six-noun face
 
 - **`harness()`** — the assembly as one typed value: `members · expect ·
-  require · settings` (`specs/architecture/40-composition.md`).
-- **`kind<T>()` / `genre<T>()`** — the engine room: a kind is a typed
+  require · settings` (`specs/model/pipeline.md`, "The SDK").
+- **`kind<T>()`** — the engine room: a kind is a typed
   constructor plus five facts of runtime residue (label, locus, layout,
-  registration, edge fields — `specs/architecture/15-kinds.md`). The built-in
-  Claude Code kinds `rule` / `skill` / `memory` are ordinary `kind<T>()` values.
+  registration, edge fields — `specs/model/representation.md`). The built-in
+  Claude Code kinds `rule` / `skill` / `memory` are ordinary `kind<T>()` values;
+  an embedded child kind is the same constructor at the `embedded` locus.
 - **Clause values** — `clause(predicate, { severity, guidance, cite })` over the
   closed predicate algebra (`required`, `maxLines`, …); a floor is an exported
-  clause array, adopted by spread in `expect` (`specs/architecture/10-contracts.md`).
+  clause array, adopted by spread in `expect` (`specs/model/contract.md`).
 - **`needs`** — the capabilities a member uses (`bash("git diff")`); emit derives
   the permission union, so a permission is never authored twice.
 - **`file()` / `` text`…` `` / `blocks()`** — the three prose constructors, one
@@ -26,7 +27,8 @@ consumes only declared data, offline, no Node.
 
 ## What `emit` produces
 
-One deterministic pass over the harness, double-emit verified (law 5):
+One deterministic pass over the harness, double-emit verified
+(`specs/model/pipeline.md`, "Emit"):
 
 - **Declaration rows** — the erased program (kind facts, clauses, requirements,
   assembly facts) on the internal versioned JSON pipe and in the lock's
@@ -43,12 +45,8 @@ projection on disk; the JSON pipe is in-flight, not a committed artifact.
 
 ## Stated bounds — each a named follow-on, never silently faked
 
-- **`blocks()` composes now, renders later** — the shared genre fence format is
-  `(genre-fence-format)`, deferred until its first consumer; emit refuses to
-  project a `blocks()` body until then.
 - **The permission union is carried as data** — the fold into the settings
   artifact lands with the hook/MCP kinds it folds many-to-one.
-- **Publish name/scope** pending the PACKAGING-CHANNELS ruling; `private: true`.
 
 ## Tests
 

package/bin/temper.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * The engine launcher — channel 2's npm face (`specs/distribution.md`,
+ * "What ships"): resolve the platform's prebuilt engine binary from its
+ * `optionalDependencies` package and exec it. Fail-loud invariant: a
+ * missing platform binary is an install error with instructions, never a
+ * silent skip — if it cannot check, it fails loud.
+ */
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+
+const require = createRequire(import.meta.url);
+
+/** platform+arch → [platform package, binary path inside it]. */
+const PLATFORMS = {
+  "linux x64": ["@dtmd/temper-linux-x64", "bin/temper"],
+  "win32 x64": ["@dtmd/temper-win32-x64", "bin/temper.exe"],
+};
+
+const key = `${process.platform} ${process.arch}`;
+const entry = PLATFORMS[key];
+
+if (!entry) {
+  const supported = Object.keys(PLATFORMS).join(", ");
+  process.stderr.write(
+    `temper: no prebuilt engine binary for ${key} yet (prebuilt: ${supported}).\n` +
+      `Build from source with a Rust 1.96+ toolchain instead:\n` +
+      `  cargo install --git https://github.com/duct-tape-and-markdown/temper\n`,
+  );
+  process.exit(1);
+}
+
+const [pkg, binPath] = entry;
+let bin;
+try {
+  bin = require.resolve(`${pkg}/${binPath}`);
+} catch {
+  process.stderr.write(
+    `temper: the platform engine package ${pkg} is not installed.\n` +
+      `It ships as an optionalDependency of @dtmd/temper — an installer run\n` +
+      `with optional dependencies disabled skips it. Restore it with:\n` +
+      `  npm install ${pkg}\n`,
+  );
+  process.exit(1);
+}
+
+const result = spawnSync(bin, process.argv.slice(2), { stdio: "inherit" });
+if (result.error) {
+  process.stderr.write(`temper: failed to run ${bin}: ${result.error.message}\n`);
+  process.exit(1);
+}
+process.exit(result.status ?? 1);

package/dist/src/assembly.d.ts

@@ -1,26 +1,34 @@
 /**
- * The assembly — `harness()` takes the whole as one typed value
- * (`specs/architecture/40-composition.md`): `Harness = members · expect · require ·
- * settings`. Like every SDK type it erases at the seam — the
- * engine never sees the constructor, only the declaration rows it compiles to
- * (`20-surface.md`). There is no second authoring surface: no `temper.toml`, no
- * roster/bindings dialect (the Decision rejects both); composing partial
- * harnesses is ordinary code.
+ * The assembly — `harness()` takes the whole as one typed value: `Harness =
+ * members · expect · require · settings · mode`. Like every SDK type it
+ * erases at the seam — the engine never sees the constructor, only the
+ * declaration rows it compiles to. There is no second authoring surface: no
+ * `temper.toml`, no roster/bindings dialect (the Decision rejects both);
+ * composing partial harnesses is ordinary code.
  */
 import type { Member, KindDefinition } from "./kind.js";
 import type { Clause, Requirement } from "./contract.js";
 /**
- * One `expect` binding — universal: every member of `kind` owes these clauses
- * (`40-composition.md`). Keyed by the kind **value**, an import never a string;
- * binding is implicit — a floor is just a clause array spread into `clauses`.
+ * One `expect` binding — universal: every member of `kind` owes these clauses.
+ * Keyed by the kind **value**, an import never a string; binding is implicit
+ * — a floor is just a clause array spread into `clauses`.
  */
 export interface ExpectBinding {
-    readonly kind: KindDefinition<object>;
+    readonly kind: KindDefinition<never>;
     readonly clauses: readonly Clause[];
 }
-/** The composed harness — the four fields, erased to rows at the seam. */
+/**
+ * The declared enforcement-mode vocabulary — how firmly the `PreToolUse` guard
+ * binds a tool call, split by where the finding goes.
+ * `block`: denies the call.
+ * `warn` (default): allows the call and surfaces the finding in-band, into the
+ * live context. `note`: allows the call and records the finding out-of-band
+ * only — the next report, never the session.
+ */
+export type EnforcementMode = "note" | "warn" | "block";
+/** The composed harness — the root member's own fields, erased to rows at the seam. */
 export interface Harness {
-    /** The member roster — the assembly's imports (`40-composition.md`, "`members`"). */
+    /** The member roster — the assembly's imports. */
     readonly members: readonly Member[];
     /** Universal clause bindings, keyed by kind value. */
     readonly expect: readonly ExpectBinding[];
@@ -28,15 +36,23 @@ export interface Harness {
     readonly require: Readonly<Record<string, Requirement>>;
     /** The residual harness-level settings with no member home (a shrinking list). */
     readonly settings: Readonly<Record<string, unknown>>;
+    /**
+      * The root member's declared enforcement mode — harness-wide, overridable
+    * per member. Defaults to `warn`: temper fabricates no enforcement the
+      * author did not declare.
+    */
+    readonly mode: EnforcementMode;
 }
 /**
- * Compose the harness from its four fields — ordinary code, Turing-completeness
- * quarantined at authoring time (`00-intent.md`, the SDK Decision). Absent
- * fields default empty; the member list is the only required part.
+ * Compose the harness from its five fields — ordinary code, Turing-completeness
+ * quarantined at authoring time. Absent
+ * fields default empty (`mode` defaults `warn`); the member list is the
+ * only required part.
  */
 export declare function harness(init: {
     members: readonly Member[];
     expect?: readonly ExpectBinding[];
     require?: Readonly<Record<string, Requirement>>;
     settings?: Readonly<Record<string, unknown>>;
+    mode?: EnforcementMode;
 }): Harness;

package/dist/src/assembly.js

@@ -1,16 +1,16 @@
 /**
- * The assembly — `harness()` takes the whole as one typed value
- * (`specs/architecture/40-composition.md`): `Harness = members · expect · require ·
- * settings`. Like every SDK type it erases at the seam — the
- * engine never sees the constructor, only the declaration rows it compiles to
- * (`20-surface.md`). There is no second authoring surface: no `temper.toml`, no
- * roster/bindings dialect (the Decision rejects both); composing partial
- * harnesses is ordinary code.
+ * The assembly — `harness()` takes the whole as one typed value: `Harness =
+ * members · expect · require · settings · mode`. Like every SDK type it
+ * erases at the seam — the engine never sees the constructor, only the
+ * declaration rows it compiles to. There is no second authoring surface: no
+ * `temper.toml`, no roster/bindings dialect (the Decision rejects both);
+ * composing partial harnesses is ordinary code.
  */
 /**
- * Compose the harness from its four fields — ordinary code, Turing-completeness
- * quarantined at authoring time (`00-intent.md`, the SDK Decision). Absent
- * fields default empty; the member list is the only required part.
+ * Compose the harness from its five fields — ordinary code, Turing-completeness
+ * quarantined at authoring time. Absent
+ * fields default empty (`mode` defaults `warn`); the member list is the
+ * only required part.
  */
 export function harness(init) {
     return {
@@ -18,5 +18,6 @@ export function harness(init) {
         expect: init.expect ?? [],
         require: init.require ?? {},
         settings: init.settings ?? {},
+        mode: init.mode ?? "warn",
     };
 }

package/dist/src/builtins.d.ts

@@ -1,13 +1,13 @@
 /**
- * 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 type { KindDefinition } from "./kind.js";
 import type { Prose } from "./prose.js";
@@ -15,27 +15,67 @@ import type { Clause } from "./contract.js";
 /** A Claude Code skill — a directory whose entry file is `SKILL.md` with YAML frontmatter. */
 export interface Skill {
     /**
-     * The description trigger — always in context; the body loads on invocation
-     * (code.claude.com/docs/en/skills, retrieved 2026-07-02).
-     */
+      * The description trigger — always in context; the body loads on invocation
+      * (code.claude.com/docs/en/skills, retrieved 2026-07-02).
+    */
     readonly description: string;
     /** 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`.
+     */
+    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`.
+     */
+    readonly "user-invocable"?: boolean;
     readonly prose?: Prose;
 }
 /**
  * `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 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
+ * `identityField` — like `rule`), the skill's field schema by import, registering
+ * on the same two documented invocation channels as `skill`.
+ */
+export declare const command: KindDefinition<Skill>;
+/** A Claude Code subagent definition. */
+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).
+    */
+    readonly description: string;
+    readonly prose?: Prose;
+}
+/**
+ * `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 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).
-     */
+      * 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).
+    */
     readonly paths?: readonly string[];
     readonly prose?: Prose;
 }
@@ -58,11 +98,75 @@ export interface Memory {
  */
 export declare const memory: KindDefinition<Memory>;
 /**
- * The floor for `skill` — Anthropic's documented skill contract: the Agent
+ * 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-10).
+ * 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-10). 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-10). 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-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 declare const mcpServer: KindDefinition<McpServer>;
+/**
+ * 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
@@ -74,7 +178,7 @@ export declare const memory: KindDefinition<Memory>;
  * 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."
  *
@@ -85,12 +189,34 @@ export declare const memory: KindDefinition<Memory>;
  * that is not a command; `metadata` is the sanctioned home for versioning —
  * there is no top-level `version` field.
  */
-export declare const skillFloor: readonly Clause[];
+export declare const skillDefaultContract: readonly Clause[];
 /**
- * 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 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
+ * `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 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-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
@@ -98,9 +224,9 @@ export declare const skillFloor: readonly Clause[];
  * 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
@@ -112,18 +238,17 @@ export declare const skillFloor: readonly Clause[];
  * behavior drifts, and test a change by watching whether Claude's behavior
  * actually shifts.
  */
-export declare const ruleFloor: readonly Clause[];
+export declare const ruleDefaultContract: readonly Clause[];
 /**
- * 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
@@ -141,23 +266,63 @@ export declare const ruleFloor: readonly Clause[];
  * directory, not below it. Personal, un-shared notes go in `CLAUDE.local.md`
  * (gitignored), appended after `CLAUDE.md` at its level.
  */
-export declare const memoryAnthropicFloor: readonly Clause[];
+export declare const memoryAnthropicDefaultContract: readonly Clause[];
 /**
- * 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 declare const memoryAgentsMdFloor: readonly Clause[];
+ * `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-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 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-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 declare const mcpServerDefaultContract: readonly Clause[];