@dtmd/temper 0.0.2 → 0.0.4

package/README.md

@@ -11,7 +11,7 @@ consumes only declared data, offline, no Node.
 ## The six-noun face
 
 - **`harness()`** — the assembly as one typed value: `members · expect ·
-  require · settings · reachability` (`specs/architecture/40-composition.md`).
+  require · settings` (`specs/architecture/40-composition.md`).
 - **`kind<T>()` / `genre<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

package/dist/src/assembly.d.ts

@@ -1,14 +1,14 @@
 /**
  * The assembly — `harness()` takes the whole as one typed value
  * (`specs/architecture/40-composition.md`): `Harness = members · expect · require ·
- * settings · reachability`. Like every SDK type it erases at the seam — the
+ * 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.
  */
 import type { Member, KindDefinition } from "./kind.js";
-import type { Clause, Requirement, Severity } from "./contract.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;
@@ -18,7 +18,7 @@ export interface ExpectBinding {
     readonly kind: KindDefinition<object>;
     readonly clauses: readonly Clause[];
 }
-/** The composed harness — the five fields, erased to rows at the seam. */
+/** The composed harness — the four fields, erased to rows at the seam. */
 export interface Harness {
     /** The member roster — the assembly's imports (`40-composition.md`, "`members`"). */
     readonly members: readonly Member[];
@@ -28,11 +28,9 @@ 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 dead-registration dial — the severity of an unreachable member, or absent (no findings). */
-    readonly reachability?: Severity;
 }
 /**
- * Compose the harness from its five fields — ordinary code, Turing-completeness
+ * 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.
  */
@@ -41,5 +39,4 @@ export declare function harness(init: {
     expect?: readonly ExpectBinding[];
     require?: Readonly<Record<string, Requirement>>;
     settings?: Readonly<Record<string, unknown>>;
-    reachability?: Severity;
 }): Harness;

package/dist/src/assembly.js

@@ -1,14 +1,14 @@
 /**
  * The assembly — `harness()` takes the whole as one typed value
  * (`specs/architecture/40-composition.md`): `Harness = members · expect · require ·
- * settings · reachability`. Like every SDK type it erases at the seam — the
+ * 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.
  */
 /**
- * Compose the harness from its five fields — ordinary code, Turing-completeness
+ * 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.
  */
@@ -18,6 +18,5 @@ export function harness(init) {
         expect: init.expect ?? [],
         require: init.require ?? {},
         settings: init.settings ?? {},
-        reachability: init.reachability,
     };
 }

package/dist/src/builtins.d.ts

@@ -11,6 +11,7 @@
  */
 import type { KindDefinition } from "./kind.js";
 import type { Prose } from "./prose.js";
+import type { Clause } from "./contract.js";
 /** A Claude Code skill — a directory whose entry file is `SKILL.md` with YAML frontmatter. */
 export interface Skill {
     /**
@@ -56,3 +57,107 @@ export interface Memory {
  * a module-carried memory projects the root file.
  */
 export declare const memory: KindDefinition<Memory>;
+/**
+ * The floor 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.
+ *
+ * Checks the strictest documented profile: the spec and upload validation are
+ * hard, Claude Code's runtime is deliberately forgiving ("All fields are
+ * optional") — a skill that passes here loads everywhere the format is
+ * honored, not merely on the machine it was written on; where the runtime
+ * diverges, the clause's own guidance says so.
+ *
+ * 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 — `10-contracts.md` 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."
+ *
+ * Authoring notes the clauses cannot carry: prefer gerund or noun-phrase
+ * names (`processing-pdfs`, `pdf-processing`) over vague ones (`helper`,
+ * `utils`); `disable-model-invocation: true` for side-effectful workflows you
+ * want to time yourself; `user-invocable: false` for background knowledge
+ * 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[];
+/**
+ * The floor 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.
+ *
+ * `paths` is the one documented frontmatter key for rules: glob patterns
+ * (brace expansion supported) that scope the rule to matching files. Rules
+ * without it load at launch with the same priority as CLAUDE.md; path-scoped
+ * 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
+ * presence predicate, and its absence is not itself a predicate.)
+ * https://code.claude.com/docs/en/memory#path-specific-rules (retrieved 2026-07-01)
+ *
+ * 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
+ * 2-space indentation", not "format code properly"). If an entry is a
+ * multi-step procedure or only matters occasionally, it belongs in a skill
+ * (on-demand) rather than a rule (always-on). Prefer path-scoped rules when
+ * one convention governs scattered paths; prefer per-directory CLAUDE.md when
+ * directory owners maintain their own. Treat rules like code: prune them when
+ * behavior drifts, and test a change by watching whether Claude's behavior
+ * actually shifts.
+ */
+export declare const ruleFloor: readonly Clause[];
+/**
+ * The floor 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.
+ *
+ * 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
+ * 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
+ * budget; everything else the contract could say is guidance.
+ *
+ * What the clauses cannot carry, as guidance: a `paths:` frontmatter block
+ * belongs on a `.claude/rules/*.md` file, not on `CLAUDE.md` — the memory
+ * docs document `paths` only for rules, so a rules-style header on
+ * `CLAUDE.md` is dead configuration. Split a large file with `@path` imports
+ * (resolved relative to the importing file, absolute allowed, recursion
+ * capped at four hops; wrap a path in backticks to mention it without
+ * importing). If the repo already ships an `AGENTS.md` for other agents,
+ * don't duplicate it — create a `CLAUDE.md` that `@AGENTS.md`-imports it (or
+ * symlink, except on Windows where the import is the recommended bridge).
+ * Mind the loading asymmetry: every ancestor `CLAUDE.md` loads in full at
+ * launch, while files in subdirectories load only when Claude reads a file
+ * there — so a rule that must always hold belongs above the working
+ * 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[];
+/**
+ * The floor 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
+ * gate, or a forbidden-key list would assert a contract the standard
+ * disclaims (`specs/intent/00-intent.md`, law 3). 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[];

package/dist/src/builtins.js

@@ -10,6 +10,7 @@
  * package — the provider face is a subpath export") — never from the root.
  */
 import { kind } from "./kind.js";
+import { allowedChars, clause, deny, forbiddenKeys, maxLen, maxLines, minLen, nameMatchesDir, required, } from "./contract.js";
 /**
  * `skill` — `.claude/skills/<name>/SKILL.md`, a directory unit, YAML frontmatter
  * carrying `name` then `description`; registers a description trigger
@@ -49,3 +50,185 @@ export const memory = kind({
     unitShape: "file",
     registration: { via: "always" },
 });
+/**
+ * The floor 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.
+ *
+ * Checks the strictest documented profile: the spec and upload validation are
+ * hard, Claude Code's runtime is deliberately forgiving ("All fields are
+ * optional") — a skill that passes here loads everywhere the format is
+ * honored, not merely on the machine it was written on; where the runtime
+ * diverges, the clause's own guidance says so.
+ *
+ * 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 — `10-contracts.md` 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."
+ *
+ * Authoring notes the clauses cannot carry: prefer gerund or noun-phrase
+ * names (`processing-pdfs`, `pdf-processing`) over vague ones (`helper`,
+ * `utils`); `disable-model-invocation: true` for side-effectful workflows you
+ * want to time yourself; `user-invocable: false` for background knowledge
+ * that is not a command; `metadata` is the sanctioned home for versioning —
+ * there is no top-level `version` field.
+ */
+export const skillFloor = [
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+    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)",
+    }),
+];
+/**
+ * The floor 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.
+ *
+ * `paths` is the one documented frontmatter key for rules: glob patterns
+ * (brace expansion supported) that scope the rule to matching files. Rules
+ * without it load at launch with the same priority as CLAUDE.md; path-scoped
+ * 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
+ * presence predicate, and its absence is not itself a predicate.)
+ * https://code.claude.com/docs/en/memory#path-specific-rules (retrieved 2026-07-01)
+ *
+ * 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
+ * 2-space indentation", not "format code properly"). If an entry is a
+ * multi-step procedure or only matters occasionally, it belongs in a skill
+ * (on-demand) rather than a rule (always-on). Prefer path-scoped rules when
+ * one convention governs scattered paths; prefer per-directory CLAUDE.md when
+ * directory owners maintain their own. Treat rules like code: prune them when
+ * behavior drifts, and test a change by watching whether Claude's behavior
+ * actually shifts.
+ */
+export const ruleFloor = [
+    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)",
+    }),
+    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)",
+    }),
+];
+/**
+ * The floor 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.
+ *
+ * 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
+ * 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
+ * budget; everything else the contract could say is guidance.
+ *
+ * What the clauses cannot carry, as guidance: a `paths:` frontmatter block
+ * belongs on a `.claude/rules/*.md` file, not on `CLAUDE.md` — the memory
+ * docs document `paths` only for rules, so a rules-style header on
+ * `CLAUDE.md` is dead configuration. Split a large file with `@path` imports
+ * (resolved relative to the importing file, absolute allowed, recursion
+ * capped at four hops; wrap a path in backticks to mention it without
+ * importing). If the repo already ships an `AGENTS.md` for other agents,
+ * don't duplicate it — create a `CLAUDE.md` that `@AGENTS.md`-imports it (or
+ * symlink, except on Windows where the import is the recommended bridge).
+ * Mind the loading asymmetry: every ancestor `CLAUDE.md` loads in full at
+ * launch, while files in subdirectories load only when Claude reads a file
+ * there — so a rule that must always hold belongs above the working
+ * directory, not below it. Personal, un-shared notes go in `CLAUDE.local.md`
+ * (gitignored), appended after `CLAUDE.md` at its level.
+ */
+export const memoryAnthropicFloor = [
+    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)",
+    }),
+];
+/**
+ * The floor 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
+ * gate, or a forbidden-key list would assert a contract the standard
+ * disclaims (`specs/intent/00-intent.md`, law 3). 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 = [];

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

@@ -5,9 +5,11 @@
  * 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) join
- * this entry when they are authored in `sdk/src`; today only the three kinds
- * exist.
+ * 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"`.
  */
 export type { Memory, Rule, Skill } from "./builtins.js";
-export { memory, rule, skill } from "./builtins.js";
+export { memory, memoryAgentsMdFloor, memoryAnthropicFloor, rule, ruleFloor, skill, skillFloor } 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

@@ -5,8 +5,9 @@
  * 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) join
- * this entry when they are authored in `sdk/src`; today only the three kinds
- * exist.
+ * 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"`.
  */
-export { memory, rule, skill } from "./builtins.js";
+export { memory, memoryAgentsMdFloor, memoryAnthropicFloor, rule, ruleFloor, skill, skillFloor } from "./builtins.js";
+export { blocks, file, text } from "./prose.js";

package/dist/src/contract.d.ts

@@ -1,29 +1,53 @@
 /**
  * Contracts — clauses and requirements as typed values (`specs/architecture/10-contracts.md`).
  * A clause is `predicate · severity · guidance · cite`; a requirement is
- * `means · kind · required · count? · unique? · membership? · degree? · verifiedBy?`.
- * Both erase to compiled data at the seam (`20-surface.md`): 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).
+ * `means · kind · required · clauses? · verifiedBy?`. Both erase to compiled data
+ * at the seam (`20-surface.md`): 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).
  */
 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`). The compiled
- * clause row records only `key`, the targeted `field` (when it names one), and
- * severity — the reduced shape the lock and the JSON pipe both carry; a
- * predicate's scalar bounds (`args`) stay author-side until the fuller
- * interchange lands its consumer (the entry gate, `20-surface.md`).
+ * A member of the closed predicate algebra (`10-contracts.md`). 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
+ * a requirement's `count`/`target`/`degree`, so the lock encodes the floor
+ * losslessly rather than identity+severity alone.
  */
 export interface Predicate {
     /** The predicate's clause key (`required`, `max_len`, `max_lines`, …). */
     readonly key: string;
     /** The field (or marker) the predicate constrains, when it names one. */
     readonly field?: string;
-    /** The predicate's scalar bounds — author-side; not yet in the erased row. */
+    /** The predicate's scalar bounds, keyed per predicate (`min`/`max`,
+     * `incoming_min`/`incoming_max`/`outgoing_min`/`outgoing_max`). */
     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").
+     */
+    readonly target?: string;
+    /** `allowed_chars`'s declared character class (`10-contracts.md`, "allowed_chars"). */
+    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[];
+}
+/**
+ * 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
+ * span (`src/contract.rs` `parse_range`'s wire spelling).
+ */
+export interface Charset {
+    readonly ranges?: readonly string[];
+    readonly chars?: string;
 }
 /** A field or marker is present. */
 export declare const required: (field: string) => Predicate;
@@ -34,15 +58,37 @@ export declare const minLen: (field: string, n: number) => Predicate;
 /** The field's value is at most `n` characters. */
 export declare const maxLen: (field: string, n: number) => Predicate;
 /** The field's characters are drawn from a declared class (`allowed_chars`). */
-export declare const allowedChars: (field: string) => Predicate;
+export declare const allowedChars: (field: string, charset: Charset) => Predicate;
 /** The member's body is at most `n` lines. */
 export declare const maxLines: (n: number) => Predicate;
 /** The forbidden keys (e.g. the Cursor `globs`/`alwaysApply` keys) are absent. */
-export declare const forbiddenKeys: () => Predicate;
+export declare const forbiddenKeys: (keys: readonly string[]) => Predicate;
+/** The field's value is none of `values` (forbidden values). */
+export declare const deny: (field: string, values: readonly string[]) => Predicate;
 /** The named headings are present. */
 export declare const requireSections: () => Predicate;
 /** The member's name matches its directory. */
 export declare const nameMatchesDir: () => Predicate;
+/** The satisfier set's size lies in the inclusive `[min, max]` bound. */
+export declare const count: (bounds: {
+    min?: number;
+    max?: number;
+}) => Predicate;
+/** The field's extracted value does not repeat across the satisfier set. */
+export declare const unique: (field: string) => Predicate;
+/** Every satisfier's `field` value is drawn from a feature over `target`'s own satisfier set. */
+export declare const membership: (field: string, target: string) => Predicate;
+/** The in/out edge-count bound every satisfier must land in. At least one direction must be given. */
+export declare const degree: (bounds: {
+    incoming?: {
+        min?: number;
+        max?: number;
+    };
+    outgoing?: {
+        min?: number;
+        max?: number;
+    };
+}) => Predicate;
 /**
  * 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
@@ -64,20 +110,18 @@ export declare function clause(predicate: Predicate, opts: {
  * 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; the set-scope facets measure the
- * satisfier set; `verifiedBy` wires the behavioral remainder.
+ * `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.
  */
 export interface Requirement {
     readonly means: string;
     readonly kind?: KindDefinition<object>;
     readonly required?: boolean;
-    readonly count?: {
-        readonly min?: number;
-        readonly max?: number;
-    };
-    readonly unique?: string;
-    readonly membership?: string;
-    readonly degree?: string;
+    readonly clauses?: readonly Clause[];
     readonly verifiedBy?: string;
 }
 /** An identity helper — types a requirement literal at the keystroke (`40-composition.md`). */

package/dist/src/contract.js

@@ -1,11 +1,11 @@
 /**
  * Contracts — clauses and requirements as typed values (`specs/architecture/10-contracts.md`).
  * A clause is `predicate · severity · guidance · cite`; a requirement is
- * `means · kind · required · count? · unique? · membership? · degree? · verifiedBy?`.
- * Both erase to compiled data at the seam (`20-surface.md`): 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).
+ * `means · kind · required · clauses? · verifiedBy?`. Both erase to compiled data
+ * at the seam (`20-surface.md`): 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).
  */
 // Node-scope predicates (`10-contracts.md`, "The predicate algebra").
 /** A field or marker is present. */
@@ -17,15 +17,59 @@ export const minLen = (field, n) => ({ key: "min_len", field, args: { min: n } }
 /** The field's value is at most `n` characters. */
 export const maxLen = (field, n) => ({ key: "max_len", field, args: { max: n } });
 /** The field's characters are drawn from a declared class (`allowed_chars`). */
-export const allowedChars = (field) => ({ key: "allowed_chars", field });
+export const allowedChars = (field, charset) => ({
+    key: "allowed_chars",
+    field,
+    charset,
+});
 /** The member's body is at most `n` lines. */
 export const maxLines = (n) => ({ key: "max_lines", args: { max: n } });
 /** The forbidden keys (e.g. the Cursor `globs`/`alwaysApply` keys) are absent. */
-export const forbiddenKeys = () => ({ key: "forbidden_keys" });
+export const forbiddenKeys = (keys) => ({ key: "forbidden_keys", keys });
+/** The field's value is none of `values` (forbidden values). */
+export const deny = (field, values) => ({
+    key: "deny",
+    field,
+    values,
+});
 /** The named headings are present. */
 export const requireSections = () => ({ key: "require_sections" });
 /** The member's name matches its directory. */
 export const nameMatchesDir = () => ({ key: "name-matches-dir" });
+// Node-set/edge-scope predicates (`10-contracts.md`, "Judged at the node-set
+// scope" / "Judged at the edge scope") — a requirement's set-scope demands ride
+// these as ordinary clause values, the same four-channel `clause()` shape as
+// the node-scope predicates above.
+/** The satisfier set's size lies in the inclusive `[min, max]` bound. */
+export const count = (bounds) => {
+    const args = {};
+    if (bounds.min !== undefined)
+        args.min = bounds.min;
+    if (bounds.max !== undefined)
+        args.max = bounds.max;
+    return { key: "count", args };
+};
+/** The field's extracted value does not repeat across the satisfier set. */
+export const unique = (field) => ({ key: "unique", field });
+/** Every satisfier's `field` value is drawn from a feature over `target`'s own satisfier set. */
+export const membership = (field, target) => ({
+    key: "membership",
+    field,
+    target,
+});
+/** The in/out edge-count bound every satisfier must land in. At least one direction must be given. */
+export const degree = (bounds) => {
+    const args = {};
+    if (bounds.incoming?.min !== undefined)
+        args.incoming_min = bounds.incoming.min;
+    if (bounds.incoming?.max !== undefined)
+        args.incoming_max = bounds.incoming.max;
+    if (bounds.outgoing?.min !== undefined)
+        args.outgoing_min = bounds.outgoing.min;
+    if (bounds.outgoing?.max !== undefined)
+        args.outgoing_max = bounds.outgoing.max;
+    return { key: "degree", args };
+};
 /** Compose a clause value — a predicate under a declared severity, with optional guidance/cite. */
 export function clause(predicate, opts) {
     return { predicate, severity: opts.severity, guidance: opts.guidance, cite: opts.cite };