@dtmd/temper 0.0.3 → 0.0.6

package/dist/src/builtins.js

@@ -1,27 +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, 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",
 });
 /**
@@ -34,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
@@ -47,5 +80,232 @@ export const memory = kind({
     name: "memory",
     locus: { kind: "at", root: ".", glob: "**/CLAUDE.md" },
     unitShape: "file",
-    registration: { via: "always" },
+    registration: [{ via: "always" }],
 });
+/**
+ * The default contract for `skill` — Anthropic's documented skill contract: the Agent
+ * Skills open standard (agentskills.io), Anthropic's platform upload
+ * validation, and Claude Code's own docs.
+ * All sources retrieved 2026-07-09.
+ *
+ * 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 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 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-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-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-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-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-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-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-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-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-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-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-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-09)",
+    }),
+];
+/**
+ * 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-09.
+ *
+ * `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: `required` is the one
+ * presence predicate, and its absence is not itself a predicate.)
+ * https://code.claude.com/docs/en/memory#path-specific-rules (retrieved 2026-07-09)
+ *
+ * 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 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-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-09)",
+    }),
+];
+/**
+ * The default contract for the qualified `claude-code.memory` kind — Anthropic's
+ * documented contract for a project `CLAUDE.md` (`packages/memory.anthropic/PACKAGE.md`,
+ * the curated authoring reference this migrates verbatim). Retrieved 2026-07-09.
+ *
+ * Deliberately near-empty, because the format is: `CLAUDE.md` is plain
+ * markdown with no documented frontmatter and no required fields
+ * (code.claude.com/docs/en/memory, retrieved 2026-07-09), so there is no
+ * schema to gate — manufacturing a required field or a forbidden-key list
+ * would fake a check the format does not carry. The single clause is a context-cost
+ * budget; everything else the contract could say is guidance.
+ *
+ * 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 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-09)",
+    }),
+];
+/**
+ * The default contract for the qualified `agents-md.memory` kind — the AGENTS.md
+ * standard's contract for a memory file, which is that there is almost none
+ * (`packages/memory.agents-md/PACKAGE.md`, the curated authoring reference
+ * this migrates). Guidance-only, and that is the honest encoding: `AGENTS.md`
+ * "is just standard Markdown" with no required fields, no sections, and no
+ * frontmatter (agents.md, retrieved 2026-07-09); the format deliberately
+ * constrains nothing. A default contract that manufactured a required field, a size
+ * gate, or a forbidden-key list would assert a contract the standard
+ * disclaims. Even the tempting size
+ * number is a *tool's* rule, not the format's: agents read the closest
+ * `AGENTS.md` in the tree (nested, nearest-wins; agents.md, retrieved
+ * 2026-07-09); Codex concatenates the chain root-to-cwd and stops once
+ * combined size hits a byte budget, not a per-file line count
+ * (`project_doc_max_bytes`, 32 KiB default;
+ * developers.openai.com/codex/guides/agents-md, retrieved 2026-07-09);
+ * Gemini CLI reads `GEMINI.md` by default and only treats `AGENTS.md` as an
+ * alias when configured via `context.fileName` (geminicli.com/docs/cli/gemini-md,
+ * retrieved 2026-07-09); Claude Code does not read `AGENTS.md` natively —
+ * bridge it with a `CLAUDE.md` that `@AGENTS.md`-imports it
+ * (code.claude.com/docs/en/memory, retrieved 2026-07-09).
+ */
+export const memoryAgentsMdDefaultContract = [];

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) join
- * this entry when they are authored in `sdk/src`; today only the three kinds
- * exist.
+ * 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, rule, skill } from "./builtins.js";
+export type { Agent, Memory, Rule, Skill } from "./builtins.js";
+export { agent, agentDefaultContract, command, commandDefaultContract, 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) join
- * this entry when they are authored in `sdk/src`; today only the three kinds
- * exist.
+ * 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, rule, skill } from "./builtins.js";
+export { agent, agentDefaultContract, command, commandDefaultContract, memory, memoryAgentsMdDefaultContract, memoryAnthropicDefaultContract, rule, ruleDefaultContract, skill, skillDefaultContract, } from "./builtins.js";
 export { blocks, file, text } from "./prose.js";

package/dist/src/contract.d.ts

@@ -1,29 +1,60 @@
 /**
- * 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 · 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).
+ * `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.
  */
 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. 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.
+     */
+    readonly target?: string;
+    /** `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-]`. 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,19 +65,58 @@ 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;
+/** 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;
+    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
- * a maintained floor auditable (`10-contracts.md`, "The clause").
+ * a maintained floor auditable.
  */
 export interface Clause {
     readonly predicate: Predicate;
@@ -61,24 +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; the set-scope facets measure the
- * satisfier set; `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 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`). */
+/** An identity helper — types a requirement literal at the keystroke. */
 export declare function requirement(init: Requirement): Requirement;

package/dist/src/contract.js

@@ -1,13 +1,12 @@
 /**
- * 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 · 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).
+ * `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.
  */
-// Node-scope predicates (`10-contracts.md`, "The predicate algebra").
+// Node-scope predicates.
 /** A field or marker is present. */
 export const required = (field) => ({ key: "required", field });
 /** The field's parsed scalar type is as declared. */
@@ -17,20 +16,91 @@ 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" });
+/** Names are unique within the artifact kind (a scope-wide identity collision). */
+export const uniqueName = () => ({ key: "unique-name" });
+/**
+ * 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 const optional = (field) => ({ key: "optional", field });
+/** The field's numeric value lies within the inclusive `[min, max]` bound. */
+export const range = (field, min, max) => ({
+    key: "range",
+    field,
+    range: { min, max },
+});
+/** The field's value is one of `values`. Spelled `enumOf` — `enum` is a reserved word. */
+export const enumOf = (field, values) => ({
+    key: "enum",
+    field,
+    values,
+});
+/** The named body marker is defined (e.g. `disable-model-invocation`). */
+export const mustDefine = (marker) => ({ key: "must_define", field: marker });
+/** Every body section whose heading *starts with* `heading` carries `marker` in its body. */
+export const sectionContains = (heading, marker) => ({
+    key: "section_contains",
+    section: { heading, marker },
+});
+// Node-set/edge-scope predicates — 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 };
 }
-/** An identity helper — types a requirement literal at the keystroke (`40-composition.md`). */
+/** An identity helper — types a requirement literal at the keystroke. */
 export function requirement(init) {
     return init;
 }