@dtmd/temper 0.0.12 → 0.0.13

package/README.md

@@ -16,8 +16,9 @@ installed:
 npx @dtmd/temper check --harness .
 ```
 
-It validates every skill, rule, and agent against the documented Anthropic
-schemas and best practices, then reports what is malformed, what Claude Code
+It validates every member Claude Code reads, from skills and rules to hooks,
+MCP servers, and plugin manifests, against the documented Anthropic schemas
+and best practices, then reports what is malformed, what Claude Code
 silently ignores, and what a requirement you declared would strand. Every
 finding arrives with its guidance attached.
 

package/dist/src/builtins.d.ts

@@ -314,6 +314,16 @@ export declare const SETTINGS_MANIFEST = "settings.json";
  * temper ships — the read side of 0021's manifest-authoring surface.
  */
 export declare const hook: KindDefinition<Hook>;
+/**
+ * The tap hook registration's `hooks.<Event>` key-path and `Hook` field triple — the
+ * provider fact {@link tapHookRows} (`declarations.ts`) fills rather than authors inline.
+ * A tap hook always fires a `command` handler (`type` fixed), so only the tap's own
+ * `command` string and the per-event `matcher` {@link TELEMETRY_EVENT_HOOKS} names vary.
+ */
+export declare function tapHookRegistration(command: string, matcher: string): {
+    readonly keyPath: string;
+    readonly fields: Array<[string, unknown]>;
+};
 /**
  * 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

package/dist/src/builtins.js

@@ -115,6 +115,9 @@ export const memory = kind({
  * registrations surface inside (code.claude.com/docs/en/settings, retrieved 2026-07-16).
  */
 export const SETTINGS_MANIFEST = "settings.json";
+/** The `hooks.<Event>` collection address's key-path — the `hook` kind's own address, and
+ * the tap hook registration's, since a tap hook is an ordinary `hook` entry. */
+const HOOK_KEY_PATH = "hooks.<Event>";
 /**
  * `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
@@ -128,9 +131,25 @@ export const hook = kind({
     unitShape: "file",
     registration: [{ via: "event", field: "event" }],
     shape: "fields",
-    collectionAddress: { manifest: SETTINGS_MANIFEST, keyPath: "hooks.<Event>", entryShape: "group-array(hooks;matcher)" },
+    collectionAddress: { manifest: SETTINGS_MANIFEST, keyPath: HOOK_KEY_PATH, entryShape: "group-array(hooks;matcher)" },
     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).",
 });
+/**
+ * The tap hook registration's `hooks.<Event>` key-path and `Hook` field triple — the
+ * provider fact {@link tapHookRows} (`declarations.ts`) fills rather than authors inline.
+ * A tap hook always fires a `command` handler (`type` fixed), so only the tap's own
+ * `command` string and the per-event `matcher` {@link TELEMETRY_EVENT_HOOKS} names vary.
+ */
+export function tapHookRegistration(command, matcher) {
+    return {
+        keyPath: HOOK_KEY_PATH,
+        fields: [
+            ["type", "command"],
+            ["command", command],
+            ["matcher", matcher],
+        ],
+    };
+}
 /**
  * `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.*`

package/dist/src/contract.d.ts

@@ -275,7 +275,7 @@ export declare const script: (path: string) => Verifier;
  * A telemetry verifier — the named documented harness events the emitted tap records
  * to a local-locus log, judged by reading the field record. Each name must be a
  * documented harness lifecycle event — the gate checks each resolves, never records
- * into it. See `TELEMETRY_EVENT_HOOKS` in `declarations.ts` for the vocabulary.
+ * into it. See `TELEMETRY_EVENT_HOOKS` in `builtins.ts` for the vocabulary.
  */
 export declare const telemetry: (events: readonly string[]) => Verifier;
 /**

package/dist/src/contract.js

@@ -209,7 +209,7 @@ export const script = (path) => ({ species: "script", path });
  * A telemetry verifier — the named documented harness events the emitted tap records
  * to a local-locus log, judged by reading the field record. Each name must be a
  * documented harness lifecycle event — the gate checks each resolves, never records
- * into it. See `TELEMETRY_EVENT_HOOKS` in `declarations.ts` for the vocabulary.
+ * into it. See `TELEMETRY_EVENT_HOOKS` in `builtins.ts` for the vocabulary.
  */
 export const telemetry = (events) => ({ species: "telemetry", events });
 /** An identity helper — types a requirement literal at the keystroke. */

package/dist/src/declarations.d.ts

@@ -70,8 +70,10 @@ export declare function buildTapHookDedupeKey(event: string, matcher: string): s
  * records every fire and read time joins raw events to members, so however many
  * verifiers name an event it takes exactly one hook — the derived-aggregate precedent
  * the permission union sets ({@link permissionUnion}). Each row runs {@link TAP_COMMAND}
- * under the event's documented matcher ({@link TELEMETRY_EVENT_HOOKS}); an event-name
- * outside that table is the roster's inadmissibility finding, never a row.
+ * under the event's documented matcher ({@link TELEMETRY_EVENT_HOOKS}), its key-path and
+ * field triple sourced from the provider face ({@link tapHookRegistration},
+ * `builtins.ts`); an event-name outside that table is the roster's inadmissibility
+ * finding, never a row.
  */
 export declare function tapHookRows(harness: Harness): RegistrationRow[];
 /**

package/dist/src/declarations.js

@@ -10,7 +10,7 @@
  */
 import { fileURLToPath } from "node:url";
 import { isTextSpan, resolveLeaf } from "./prose.js";
-import { SETTINGS_MANIFEST, TELEMETRY_EVENT_HOOKS } from "./builtins.js";
+import { SETTINGS_MANIFEST, TELEMETRY_EVENT_HOOKS, tapHookRegistration } from "./builtins.js";
 /**
  * Compile one `Clause` into its lock row: the shared `key`/`field`/`severity`/
  * `guidance`/`cite` columns — the clause's four channels surviving erasure
@@ -223,20 +223,19 @@ function collectionAddressRow(facts) {
     };
 }
 /**
- * One kind's fact row — an `at` locus supplies `governs_root`/`governs_glob` and a
- * nested-file kind neither (its path composes from its host's unit and the host
- * template's pattern, so it governs no glob). A file locus's `commitment` class rides
- * the same spelling, absent for the committed default. `templates` names the embedded kinds the
- * corpus admits over it, and `content` lowers a declared layout (absent for a
- * `file`-content kind). A registration kind extends the row with its `shape` marker and
- * `collection_address`. Advisory `guidance`/`cite` pair rides alongside (decision 0045).
+ * One kind's fact row — an `at` locus supplies `governs_root`/`governs_glob` and any
+ * other locus neither (a nested-file kind's path composes from its host's unit and the
+ * host template's pattern; an embedded kind owns no unit at all — both govern no glob).
+ * A file locus's `commitment` class rides the same spelling, absent for the committed
+ * default. `templates` names the embedded kinds the corpus admits over it, and `content`
+ * lowers a declared layout (absent for a `file`-content kind). A registration kind
+ * extends the row with its `shape` marker and `collection_address`. Advisory
+ * `guidance`/`cite` pair rides alongside, locus-optional so an embedded kind's own
+ * counsel reaches the lock the same way a nested-file kind's already does (decision
+ * 0045) — callable for any locus; [`kindFactKindsInPlay`] decides which embedded kinds
+ * actually take a row.
  */
 function kindFactRow(facts, admissions) {
-    if (facts.locus.kind === "embedded") {
-        // An embedded kind inherits its world residue through its host; it owns no unit at
-        // all, so it takes no kind-fact row. Callers filter these out before this point.
-        throw new Error(`kind \`${facts.name}\` is embedded — it carries no locus-bearing kind fact.`);
-    }
     const governs = facts.locus.kind === "at" ? facts.locus : undefined;
     return {
         name: facts.name,
@@ -298,12 +297,15 @@ function atLocusKindsInPlay(allKinds) {
     return allKinds.filter((facts) => facts.locus.kind === "at");
 }
 /**
- * The distinct unit-owning kinds in play — every locus but `embedded`. The kinds that
- * take a fact row: a nested-file kind owns a file the engine must place, and places it
- * off its row, though it governs no glob to be discovered at.
+ * The distinct kinds in play that take a kind-fact row: every non-embedded locus
+ * unconditionally (a nested-file kind owns a file the engine must place, and places it
+ * off its row, though it governs no glob to be discovered at), plus an embedded kind
+ * only when it declares `guidance` or `cite` of its own (decision 0045) — an embedded
+ * kind with neither has nothing for the row to carry, and its members already reach the
+ * corpus through their host's `templates` column alone (`kindsInPlay`), never the row.
  */
-function unitKindsInPlay(allKinds) {
-    return allKinds.filter((facts) => facts.locus.kind !== "embedded");
+function kindFactKindsInPlay(allKinds) {
+    return allKinds.filter((facts) => facts.locus.kind !== "embedded" || facts.guidance !== undefined || facts.cite !== undefined);
 }
 /** The requirement rows — assembly `require` and every member's `requires`, one namespace. */
 function requirementRows(harness) {
@@ -648,8 +650,10 @@ export function buildTapHookDedupeKey(event, matcher) {
  * records every fire and read time joins raw events to members, so however many
  * verifiers name an event it takes exactly one hook — the derived-aggregate precedent
  * the permission union sets ({@link permissionUnion}). Each row runs {@link TAP_COMMAND}
- * under the event's documented matcher ({@link TELEMETRY_EVENT_HOOKS}); an event-name
- * outside that table is the roster's inadmissibility finding, never a row.
+ * under the event's documented matcher ({@link TELEMETRY_EVENT_HOOKS}), its key-path and
+ * field triple sourced from the provider face ({@link tapHookRegistration},
+ * `builtins.ts`); an event-name outside that table is the roster's inadmissibility
+ * finding, never a row.
  */
 export function tapHookRows(harness) {
     const deduped = new Map();
@@ -670,17 +674,16 @@ export function tapHookRows(harness) {
     }
     return [...deduped.values()]
         .sort((a, b) => compareStrings(a.event, b.event) || compareStrings(a.matcher, b.matcher))
-        .map(({ event, matcher }) => ({
-        kind: "hook",
-        key: event,
-        manifest: SETTINGS_MANIFEST,
-        key_path: "hooks.<Event>",
-        fields: [
-            ["type", "command"],
-            ["command", TAP_COMMAND],
-            ["matcher", matcher],
-        ],
-    }));
+        .map(({ event, matcher }) => {
+        const { keyPath, fields } = tapHookRegistration(TAP_COMMAND, matcher);
+        return {
+            kind: "hook",
+            key: event,
+            manifest: SETTINGS_MANIFEST,
+            key_path: keyPath,
+            fields,
+        };
+    });
 }
 /**
  * The `settings` rows — the assembly's harness-level residual settings keys, each folded
@@ -762,7 +765,7 @@ export function compileDeclarations(harness, placements, extents) {
         }
     }
     return {
-        kinds: unitKindsInPlay(allKinds).map((facts) => kindFactRow(facts, admissions)),
+        kinds: kindFactKindsInPlay(allKinds).map((facts) => kindFactRow(facts, admissions)),
         clauses,
         requirements: requirementRows(harness),
         assembly: assemblyFactRows(harness, allKinds),

package/dist/src/generated/Features.d.ts

@@ -94,7 +94,7 @@ export type Features = {
     /**
      * The host member's own **nested members** — its declared [`EmbeddedMember`]s,
      * read off the lock's own `Declarations::nested_members` rows by this member's
-     * `kind:name` address ([`nested_members_from_rows`]), never mined from
+     * `kind:name` address ([`nested_members_from_rows`](crate::drift::nested_members_from_rows)), never mined from
      * [`fenced_blocks`](Features::fenced_blocks) (0018, "the projection is not the
      * database"). Empty when the lock carries no row for this member.
      */

package/dist/src/generated/RequirementRow.d.ts

@@ -31,7 +31,7 @@ export type RequirementRow = {
     clauses: Array<ClauseRow>;
     /**
      * The typed verifier for the behavioral remainder, when declared — a
-     * species-tagged [`Verifier`], resolved at admissibility, never run.
+     * species-tagged [`Verifier`](crate::compose::Verifier), resolved at admissibility, never run.
      */
     verifier?: Verifier;
     /**

package/dist/src/index.d.ts

@@ -9,8 +9,8 @@
  * Every type erases at the seam, and Turing-completeness
  * stays quarantined at authoring time.
  *
- * The first-party Claude Code provider face — the built-in `skill`/`rule`/
- * `memory` kinds — lives at the `./claude-code` subpath, never here.
+ * The first-party Claude Code provider face — the built-in kinds — lives at
+ * the `./claude-code` subpath, never here.
  */
 export type { Blocks, File, Include, Mention, Mentionable, Prose, Reference, Text } from "./prose.js";
 export { blocks, file, include, mentionOf, renderText, text } from "./prose.js";

package/dist/src/index.js

@@ -9,8 +9,8 @@
  * Every type erases at the seam, and Turing-completeness
  * stays quarantined at authoring time.
  *
- * The first-party Claude Code provider face — the built-in `skill`/`rule`/
- * `memory` kinds — lives at the `./claude-code` subpath, never here.
+ * The first-party Claude Code provider face — the built-in kinds — lives at
+ * the `./claude-code` subpath, never here.
  */
 export { blocks, file, include, mentionOf, renderText, text } from "./prose.js";
 export { bash, capability, permissionUnion } from "./needs.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtmd/temper",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "The temper authoring face — the six-noun model as typed modules: harness(), kind<T>(), clause values, needs, and file()/text/blocks(). Emit compiles to the declaration rows the engine reads, a byte-faithful projection, and the lock.",
   "license": "(MIT OR Apache-2.0)",
   "repository": {
@@ -52,7 +52,7 @@
     "temper": "bin/temper.js"
   },
   "optionalDependencies": {
-    "@dtmd/temper-linux-x64": "0.0.12",
-    "@dtmd/temper-win32-x64": "0.0.12"
+    "@dtmd/temper-linux-x64": "0.0.13",
+    "@dtmd/temper-win32-x64": "0.0.13"
   }
 }