@dtmd/temper 0.0.6 → 0.0.7

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/builtins.d.ts

@@ -97,6 +97,71 @@ export interface Memory {
  * a module-carried memory projects the root file.
  */
 export declare const memory: KindDefinition<Memory>;
+/**
+ * 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
@@ -225,3 +290,39 @@ export declare const memoryAnthropicDefaultContract: readonly Clause[];
  * (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[];

package/dist/src/builtins.js

@@ -10,7 +10,7 @@
  * — never from the root.
  */
 import { kind } from "./kind.js";
-import { allowedChars, clause, deny, forbiddenKeys, maxLen, maxLines, minLen, nameMatchesDir, required, uniqueName, } from "./contract.js";
+import { allowedChars, clause, deny, enumOf, forbiddenKeys, maxLen, maxLines, minLen, nameMatchesDir, required, uniqueName, } from "./contract.js";
 /**
  * `skill` — `.claude/skills/<name>/SKILL.md`, a directory unit, YAML frontmatter
  * carrying `name` then `description`; registers on both documented invocation
@@ -82,6 +82,37 @@ export const memory = kind({
     unitShape: "file",
     registration: [{ via: "always" }],
 });
+/**
+ * `hook` — a `settings.json` `hooks.<Event>` registration member: a fields-only kind (no
+ * body slot), its members discovered off the `.claude/settings.json` manifest at the
+ * `hooks.<Event>` collection address, keyed by lifecycle event; registers on the `event`
+ * channel (code.claude.com/docs/en/hooks, retrieved 2026-07-10). The first manifest kind
+ * temper ships — the read side of 0021's manifest-authoring surface.
+ */
+export const hook = kind({
+    name: "hook",
+    locus: { kind: "at", root: ".claude", glob: "settings.json" },
+    unitShape: "file",
+    registration: [{ via: "event", field: "event" }],
+    shape: "fields",
+    collectionAddress: { manifest: "settings.json", keyPath: "hooks.<Event>" },
+});
+/**
+ * `mcpServer` — a `.mcp.json` `mcpServers.*` registration member: a fields-only kind (no
+ * body slot), its members discovered off the `.mcp.json` manifest at the `mcpServers.*`
+ * collection address, keyed by server name; registers on the `connection` channel
+ * (code.claude.com/docs/en/mcp, retrieved 2026-07-10). The second manifest kind temper
+ * ships, and the first whose entries are objects — each server's fields fold into the
+ * member the read surfaces.
+ */
+export const mcpServer = kind({
+    name: "mcp-server",
+    locus: { kind: "at", root: ".", glob: ".mcp.json" },
+    unitShape: "file",
+    registration: [{ via: "connection" }],
+    shape: "fields",
+    collectionAddress: { manifest: ".mcp.json", keyPath: "mcpServers.*" },
+});
 /**
  * The default contract for `skill` — Anthropic's documented skill contract: the Agent
  * Skills open standard (agentskills.io), Anthropic's platform upload
@@ -309,3 +340,99 @@ export const memoryAnthropicDefaultContract = [
  * (code.claude.com/docs/en/memory, retrieved 2026-07-09).
  */
 export const memoryAgentsMdDefaultContract = [];
+/**
+ * Every documented Claude Code hook lifecycle event — the closed set a `hooks.<Event>`
+ * key is drawn from (code.claude.com/docs/en/hooks, "Hook events", retrieved 2026-07-10).
+ * The allowlist the `hook` default contract's one decidable clause ranges over; the
+ * update ritual when the docs add an event is to re-fetch and extend this set, never to
+ * re-derive from memory.
+ */
+const DOCUMENTED_HOOK_EVENTS = [
+    "SessionStart",
+    "Setup",
+    "UserPromptSubmit",
+    "UserPromptExpansion",
+    "PreToolUse",
+    "PermissionRequest",
+    "PermissionDenied",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PostToolBatch",
+    "Notification",
+    "MessageDisplay",
+    "SubagentStart",
+    "SubagentStop",
+    "TaskCreated",
+    "TaskCompleted",
+    "Stop",
+    "StopFailure",
+    "TeammateIdle",
+    "InstructionsLoaded",
+    "ConfigChange",
+    "CwdChanged",
+    "FileChanged",
+    "WorktreeCreate",
+    "WorktreeRemove",
+    "PreCompact",
+    "PostCompact",
+    "Elicitation",
+    "ElicitationResult",
+    "SessionEnd",
+];
+/**
+ * The default contract for `hook` — Anthropic's documented hooks contract
+ * (code.claude.com/docs/en/hooks, retrieved 2026-07-10). A hook surfaces at
+ * `hooks.<Event>`, so the member the gate reads is the lifecycle event itself, its name
+ * carried as the `event` field off the collection key. The one decidable, cited property
+ * of that member is its event: a key outside the documented set is dead configuration —
+ * Claude Code silently never fires a hook under an unrecognized event, so the strictest
+ * documented profile is that the event is one temper's cited docs name.
+ *
+ * Deliberately absent — the handler's own schema (`type`/`command`/`url`/`timeout`, the
+ * matcher grammar) lives one array level deeper than `hooks.<Event>`, inside each event's
+ * matcher-group list, which the collection address does not walk into; a clause over it
+ * would range over a field the read never surfaces, so it is no clause at all. What the
+ * clauses cannot carry, as guidance: keep a handler's `type` among
+ * `command`/`http`/`mcp_tool`/`prompt`/`agent`; a `command` handler needs a `command`, an
+ * `http` handler a `url`; the `matcher` filters tool-scoped events and is inert on events
+ * that carry no tool (`UserPromptSubmit`, `Stop`, and their siblings).
+ */
+export const hookDefaultContract = [
+    clause(enumOf("event", DOCUMENTED_HOOK_EVENTS), {
+        severity: "required",
+        guidance: "A hook keys under its lifecycle event; an event outside the documented set is dead configuration — Claude Code silently never fires a hook under an unrecognized event. If this is a newly-documented event, re-fetch code.claude.com/docs/en/hooks and extend temper's cited set rather than working around the finding.",
+        cite: "https://code.claude.com/docs/en/hooks (retrieved 2026-07-10)",
+    }),
+];
+/**
+ * Every documented `.mcp.json` server transport — the closed set a server entry's `type`
+ * is drawn from (code.claude.com/docs/en/mcp, retrieved 2026-07-10). `stdio` is the
+ * default when `type` is absent; `streamable-http` is the MCP spec's own name for `http`,
+ * accepted as an alias so configurations copied from server docs work unchanged; `sse` is
+ * documented but deprecated; `ws` is the WebSocket transport. The update ritual when the
+ * docs add a transport is to re-fetch and extend this set, never to re-derive from memory.
+ */
+const DOCUMENTED_MCP_TRANSPORTS = ["stdio", "http", "streamable-http", "sse", "ws"];
+/**
+ * The default contract for `mcpServer` — Anthropic's documented `.mcp.json` contract
+ * (code.claude.com/docs/en/mcp, retrieved 2026-07-10). A server surfaces at `mcpServers.*`,
+ * keyed by name, its transport-specific fields folded into the member. The one decidable,
+ * cited property that holds across every transport is `type`: a value outside the
+ * documented set is a transport Claude Code cannot honor, so the strictest documented
+ * profile is that a present `type` names one temper's cited docs carry. An absent `type`
+ * passes — Claude Code reads it as `stdio`, the documented default.
+ *
+ * Deliberately absent — the per-transport requirements are conditional on `type`, which no
+ * single-field clause can decide: a `url` with no `type` is a configuration error (Claude
+ * Code reads it as a stdio server and skips it), a stdio server needs a `command`, and a
+ * remote server needs a `url` — each a two-field implication the closed predicate
+ * vocabulary cannot express, so it rides guidance rather than a clause that would range
+ * over a field the shape of the check cannot see.
+ */
+export const mcpServerDefaultContract = [
+    clause(enumOf("type", DOCUMENTED_MCP_TRANSPORTS), {
+        severity: "required",
+        guidance: "A server's `type` names its transport; a value outside the documented set is one Claude Code cannot honor. Absent reads as `stdio` — but an entry that carries a `url` with no `type` is then a configuration error, because Claude Code treats it as a stdio server and skips it: add `type: \"http\"` (or `sse`/`ws`). A stdio server needs a `command`; a remote server needs a `url`. If this is a newly-documented transport, re-fetch code.claude.com/docs/en/mcp and extend temper's cited set rather than working around the finding.",
+        cite: "https://code.claude.com/docs/en/mcp (retrieved 2026-07-10)",
+    }),
+];

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

@@ -7,7 +7,7 @@
  * 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 { Agent, Memory, Rule, Skill } from "./builtins.js";
-export { agent, agentDefaultContract, command, commandDefaultContract, memory, memoryAgentsMdDefaultContract, memoryAnthropicDefaultContract, rule, ruleDefaultContract, skill, skillDefaultContract, } from "./builtins.js";
+export type { Agent, Hook, McpServer, Memory, Rule, Skill } from "./builtins.js";
+export { agent, agentDefaultContract, command, commandDefaultContract, hook, hookDefaultContract, mcpServer, mcpServerDefaultContract, memory, memoryAgentsMdDefaultContract, memoryAnthropicDefaultContract, rule, ruleDefaultContract, skill, skillDefaultContract, } from "./builtins.js";
 export type { Blocks, File, Prose, Text } from "./prose.js";
 export { blocks, file, text } from "./prose.js";

package/dist/src/claude-code.js

@@ -7,5 +7,5 @@
  * 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 { agent, agentDefaultContract, command, commandDefaultContract, memory, memoryAgentsMdDefaultContract, memoryAnthropicDefaultContract, rule, ruleDefaultContract, skill, skillDefaultContract, } from "./builtins.js";
+export { agent, agentDefaultContract, command, commandDefaultContract, hook, hookDefaultContract, mcpServer, mcpServerDefaultContract, memory, memoryAgentsMdDefaultContract, memoryAnthropicDefaultContract, rule, ruleDefaultContract, skill, skillDefaultContract, } from "./builtins.js";
 export { blocks, file, text } from "./prose.js";

package/dist/src/declarations.d.ts

@@ -9,10 +9,29 @@
  * in lockstep.
  */
 import type { Harness } from "./assembly.js";
-import type { Declarations, Payload } from "./generated/index.js";
+import type { Declarations, Payload, RegistrationRow, SettingsRow } from "./generated/index.js";
 export type { AssemblyFactRow, ClauseRow, Declarations, KindFactRow, RequirementRow, SatisfiesRow, } from "./generated/index.js";
 /** The stable-sort ordering every declaration row family shares. */
 export declare function compareStrings(a: string, b: string): number;
+/**
+ * The `registration` rows — every fields-only registration member (a hook, an MCP server)
+ * erased for the manifest write face, kind-then-key sorted so double emit is byte-stable.
+ * Each carries its identity (`kind`/`key`), its collection address (`manifest`/`keyPath`,
+ * the wire's snake_case `key_path`), and its folded typed fields — the entry value the
+ * engine's write face places under `key`. The one source `emit.ts`'s public
+ * {@link RegistrationFact} view also maps from, so the seam and the `EmitResult` sibling
+ * cannot disagree on what a manifest carries.
+ *
+ * # Throws
+ * If a fields-only member declares no collection address — it surfaces in no host manifest.
+ */
+export declare function registrationRows(harness: Harness): RegistrationRow[];
+/**
+ * The `settings` rows — the assembly's harness-level residual settings keys, each folded
+ * into the settings.json manifest's opaque residue at emit. Key-sorted so double emit is
+ * byte-stable. Seam-inbound: the value lives in the projected manifest, never the lock.
+ */
+export declare function settingsRows(harness: Harness): SettingsRow[];
 /** Every requirement name a `satisfies` claim may fill — assembly `require` ∪ member `requires`. */
 export declare function declaredRequirements(harness: Harness): Set<string>;
 /**

package/dist/src/declarations.js

@@ -152,10 +152,21 @@ function contentRow(content) {
     });
     return { regions };
 }
+/**
+ * Lower a kind's declared {@link CollectionAddress} into its `collection_address` row —
+ * `keyPath` spelled as the wire's snake_case `key_path`. `undefined` for a file-locus
+ * kind, so its row omits the column and stays byte-identical.
+ */
+function collectionAddressRow(facts) {
+    if (facts.collectionAddress === undefined)
+        return undefined;
+    return { manifest: facts.collectionAddress.manifest, key_path: facts.collectionAddress.keyPath };
+}
 /**
  * One kind's fact row — the `at` locus supplies `governs_root`/`governs_glob`,
  * `templates` names the embedded kinds (among `allKinds`) declared within it, and
- * `content` lowers a declared layout (absent for a `file`-content kind).
+ * `content` lowers a declared layout (absent for a `file`-content kind). A registration
+ * kind extends the row with its `shape` marker and `collection_address`.
  */
 function kindFactRow(facts, allKinds) {
     if (facts.locus.kind !== "at") {
@@ -173,6 +184,8 @@ function kindFactRow(facts, allKinds) {
         registration: registrationLabels(facts.registration),
         templates: templatesFor(facts.name, allKinds),
         content: contentRow(facts.content),
+        shape: facts.shape,
+        collection_address: collectionAddressRow(facts),
     };
 }
 /** Every kind in play, at any locus — member kinds ∪ expect kinds ∪ their embedded children. */
@@ -402,6 +415,55 @@ function nestedMemberRows(harness, mentionable) {
     }
     return rows.sort((a, b) => compareStrings(a.host, b.host) || compareStrings(a.kind, b.kind) || compareStrings(a.key, b.key));
 }
+/**
+ * The `registration` rows — every fields-only registration member (a hook, an MCP server)
+ * erased for the manifest write face, kind-then-key sorted so double emit is byte-stable.
+ * Each carries its identity (`kind`/`key`), its collection address (`manifest`/`keyPath`,
+ * the wire's snake_case `key_path`), and its folded typed fields — the entry value the
+ * engine's write face places under `key`. The one source `emit.ts`'s public
+ * {@link RegistrationFact} view also maps from, so the seam and the `EmitResult` sibling
+ * cannot disagree on what a manifest carries.
+ *
+ * # Throws
+ * If a fields-only member declares no collection address — it surfaces in no host manifest.
+ */
+export function registrationRows(harness) {
+    return harness.members
+        .filter((member) => member.facts.shape === "fields")
+        .map((member) => {
+        const address = member.facts.collectionAddress;
+        if (address === undefined) {
+            throw new Error(`member \`${member.name}\`: a fields-only registration kind declares no ` +
+                `collection address — it surfaces in no host manifest (specs/model/pipeline.md, "The SDK").`);
+        }
+        return {
+            kind: member.kind,
+            key: member.name,
+            manifest: address.manifest,
+            key_path: address.keyPath,
+            // The generated row carries a mutable field list; the member's is read-only, so
+            // copy each pair into a fresh tuple — the same values, a shape the row accepts.
+            fields: member.fields.map(([name, value]) => [name, value]),
+        };
+    })
+        .sort((a, b) => compareStrings(a.kind, b.kind) || compareStrings(a.key, b.key));
+}
+/**
+ * The manifest Claude Code's harness-level settings reside in — the file the assembly's
+ * residual settings keys fold into as opaque residue, the same manifest the `hook` kind's
+ * registrations surface inside (code.claude.com/docs/en/settings, retrieved 2026-07-10).
+ */
+const SETTINGS_MANIFEST = "settings.json";
+/**
+ * The `settings` rows — the assembly's harness-level residual settings keys, each folded
+ * into the settings.json manifest's opaque residue at emit. Key-sorted so double emit is
+ * byte-stable. Seam-inbound: the value lives in the projected manifest, never the lock.
+ */
+export function settingsRows(harness) {
+    return Object.entries(harness.settings)
+        .map(([key, value]) => ({ manifest: SETTINGS_MANIFEST, key, value }))
+        .sort((a, b) => compareStrings(a.key, b.key));
+}
 /** Every requirement name a `satisfies` claim may fill — assembly `require` ∪ member `requires`. */
 export function declaredRequirements(harness) {
     const set = new Set();
@@ -444,6 +506,8 @@ export function compileDeclarations(harness) {
         mentions: mentionRows(harness),
         includes: includeRows(harness),
         nested_members: nestedMemberRows(harness, declaredAddresses(harness)),
+        registrations: registrationRows(harness),
+        settings: settingsRows(harness),
     };
 }
 /** The SDK's pinned engine/interchange version — the JSON pipe rides it in lockstep. */

package/dist/src/emit.d.ts

@@ -17,6 +17,40 @@ export interface ResolveOptions {
     /** The addresses a mention may name — resolution-checked; a mention cannot dangle. */
     readonly mentionable?: ReadonlySet<string>;
 }
+/**
+ * One fields-only registration member erased for the manifest write face: its key
+ * (a hook's lifecycle event, an MCP server's name), the collection address it keys
+ * at, and its folded typed fields — the same declaration-row shape the engine write
+ * face reads back off a manifest (`json_manifest.rs`'s `RegistrationMember`). Carried
+ * from the composing program, never mined from a projection.
+ */
+export interface RegistrationFact {
+    /** The erased registration kind — `hook`, `mcp-server` — joining `declarations.kinds`. */
+    readonly kind: string;
+    /** The member's key among its collection's entries — a hook's event, a server's name. */
+    readonly key: string;
+    /** The manifest collection address the registration surfaces at. */
+    readonly collectionAddress: {
+        readonly manifest: string;
+        readonly keyPath: string;
+    };
+    /** The member's folded typed fields, in the author's declared order. */
+    readonly fields: ReadonlyArray<readonly [string, unknown]>;
+}
+/**
+ * One harness-level settings-residue key erased for the manifest write face: the manifest
+ * it surfaces in, its opaque key, and its value — the entry `emit` folds into the manifest's
+ * residue beside its registration members' collection segments. Carried from the composing
+ * program, never mined from a projection.
+ */
+export interface SettingsResidue {
+    /** The host manifest the residue key surfaces in (`settings.json`). */
+    readonly manifest: string;
+    /** The opaque top-level manifest key with no member home. */
+    readonly key: string;
+    /** The key's opaque value, placed verbatim into the manifest's residue. */
+    readonly value: unknown;
+}
 /**
  * A full emit's compiled outputs — the whole seam the engine reads.
  * A pure function of the harness, so [`emit`]
@@ -39,6 +73,19 @@ export interface EmitResult {
      * data until then.
      */
     readonly permissions: readonly string[];
+    /**
+     * The fields-only registration members erased for the manifest write face — each
+     * a name, its collection address, and its folded fields. Folds into the manifest
+     * artifacts once the engine write face lands; carried here as data until then, the
+     * way `permissions` is.
+     */
+    readonly registrations: readonly RegistrationFact[];
+    /**
+     * The harness-level settings residue erased for the manifest write face — each an opaque
+     * settings.json key and its value. Folds into the settings.json manifest's residue at
+     * emit, the way `registrations` builds its collection segments; carried here as data too.
+     */
+    readonly settings: readonly SettingsResidue[];
 }
 /**
  * Compile the whole face in one deterministic pass: the declaration rows (its

package/dist/src/emit.js

@@ -12,7 +12,7 @@ import { fileURLToPath } from "node:url";
 import { readFileSync } from "node:fs";
 import { renderText, resolveLeaf } from "./prose.js";
 import { permissionUnion } from "./needs.js";
-import { compareStrings, compileDeclarations, declaredAddresses, declaredRequirements, encodeSeam, } from "./declarations.js";
+import { compareStrings, compileDeclarations, declaredAddresses, declaredRequirements, encodeSeam, registrationRows, settingsRows, } from "./declarations.js";
 /**
  * TOML-quote a leaf's authored text into a basic-string literal — the escapes
  * `toml_edit`'s parser reads back (backslash, quote, and the C0 control set),
@@ -191,9 +191,21 @@ function refuseBrokenSource(harness) {
         }
     }
 }
-/** A member is projected iff its kind lives at a path locus (an embedded member is not). */
+/**
+ * A fields-only registration member (a hook, an MCP server) surfaces embedded in a
+ * host manifest, so it owns no standalone artifact — its facts erase into a
+ * {@link RegistrationFact} for the manifest write face, never a projected member.
+ */
+function isRegistration(member) {
+    return member.facts.shape === "fields";
+}
+/**
+ * A member is projected iff its kind lives at a path locus and is not a fields-only
+ * registration member — an embedded member and a registration member each carry no
+ * standalone projection.
+ */
 function isProjected(member) {
-    return member.facts.locus.kind === "at";
+    return member.facts.locus.kind === "at" && !isRegistration(member);
 }
 /**
  * The resolved absolute path of a `file()` prose asset, or `undefined` for
@@ -211,6 +223,32 @@ function fileSourcePath(member) {
         return undefined;
     return fileURLToPath(new URL(prose.path, prose.moduleUrl));
 }
+/**
+ * The harness's fields-only registration members as the public {@link RegistrationFact}
+ * view — the seam's own `registration` rows ({@link registrationRows}) mapped to the
+ * nested `collectionAddress` shape the `EmitResult` sibling exposes, so the two cannot
+ * disagree on what a manifest carries. Kind-then-key ordered so double emit is byte-stable.
+ *
+ * # Throws
+ * If a fields-only member declares no collection address — it surfaces in no manifest.
+ */
+function registrationFacts(harness) {
+    return registrationRows(harness).map((row) => ({
+        kind: row.kind,
+        key: row.key,
+        collectionAddress: { manifest: row.manifest, keyPath: row.key_path },
+        fields: row.fields,
+    }));
+}
+/**
+ * The harness's residual settings keys as the public {@link SettingsResidue} view — the
+ * seam's own `settings` rows ({@link settingsRows}) surfaced under the `EmitResult` sibling,
+ * so the two cannot disagree on what a manifest's residue carries. Key-sorted, the same
+ * byte-stable order the seam family takes.
+ */
+function settingsResidue(harness) {
+    return settingsRows(harness).map((row) => ({ manifest: row.manifest, key: row.key, value: row.value }));
+}
 /** The harness's projected members as payload members, deterministically kind-then-name ordered. */
 function orderedMembers(harness, options) {
     return [...harness.members]
@@ -246,6 +284,8 @@ export function emit(harness) {
             members,
             seam: encodeSeam({ declarations, members }),
             permissions: permissionUnion(harness.members.flatMap((member) => [...member.needs])),
+            registrations: registrationFacts(harness),
+            settings: settingsResidue(harness),
         };
     };
     const first = compile();

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

@@ -0,0 +1,17 @@
+/**
+ * A kind's declared **collection address** row — the manifest a registration member
+ * surfaces in and the key path it keys at, the presence-coupled pair
+ * [`KindFactRow::collection_address`] carries. Absent from a [`KindFactRow`] means the
+ * kind owns its own file locus.
+ */
+export type CollectionAddressRow = {
+    /**
+     * The host manifest the registration surfaces in (`settings.json`, `.mcp.json`).
+     */
+    manifest: string;
+    /**
+     * The manifest key path the registration keys at (`hooks.<Event>`, `mcpServers.*`), a
+     * closed vocabulary the engine's kind lift rejects an unknown value from.
+     */
+    key_path: string;
+};

package/dist/src/generated/CollectionAddressRow.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

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

@@ -4,8 +4,10 @@ import type { IncludeRow } from "./IncludeRow.js";
 import type { KindFactRow } from "./KindFactRow.js";
 import type { MentionRow } from "./MentionRow.js";
 import type { NestedMemberRow } from "./NestedMemberRow.js";
+import type { RegistrationRow } from "./RegistrationRow.js";
 import type { RequirementRow } from "./RequirementRow.js";
 import type { SatisfiesRow } from "./SatisfiesRow.js";
+import type { SettingsRow } from "./SettingsRow.js";
 /**
  * The lock's **declaration-row family** — the composed program's erased declarations,
  * beside the
@@ -69,4 +71,19 @@ export type Declarations = {
      * (0018, "the projection is not the database").
      */
     nested_members: Array<NestedMemberRow>;
+    /**
+     * The fields-only registration members the SDK erased for the manifest write face —
+     * seam-inbound carrying their folded fields, so `emit` routes each host manifest whole
+     * through the canonical write face. The lock's `registration` family records only each
+     * member's identity and collection address; the fields live in the projected manifest
+     * artifact, never a second copy read back (0018), so a lock round-trip reads them
+     * fieldless.
+     */
+    registrations: Array<RegistrationRow>;
+    /**
+     * The harness-level settings residue — seam-inbound opaque `settings.json` keys with
+     * no member home, folded into their manifest's residue at emit. Like `includes`, never
+     * written into this declaration table, so a lock round-trip reads none.
+     */
+    settings: Array<SettingsRow>;
 };

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

@@ -1,3 +1,4 @@
+import type { CollectionAddressRow } from "./CollectionAddressRow.js";
 import type { LayoutRow } from "./LayoutRow.js";
 /**
  * One kind's declaration row — its identity and declared runtime facts.
@@ -48,4 +49,17 @@ export type KindFactRow = {
      * kind whose body is a declared layout over its heading tree.
      */
     content?: LayoutRow;
+    /**
+     * The **fields-only** body-shape marker — `fields` for a no-body-slot kind (a hook,
+     * an MCP server); absent for a body-bearing kind, whose body is `file` or a `content`
+     * layout. The tolerant `#[serde(default)]` round-trip the rest of the optional facts
+     * take, so a body-bearing kind's row stays byte-identical.
+     */
+    shape?: string;
+    /**
+     * The declared **collection address** — for a registration member surfacing inside a
+     * host manifest, which manifest and which key path it keys at. Absent for a
+     * file-locus kind, so an ordinary row stays byte-identical.
+     */
+    collection_address?: CollectionAddressRow;
 };

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

@@ -0,0 +1,35 @@
+/**
+ * One fields-only registration member the SDK erased for the manifest write face — a
+ * hook, an MCP server — carried across the seam so `emit` routes its host manifest whole
+ * through the canonical write face ([`crate::json_manifest::write_manifest`]) rather than
+ * the unrepresented in-place splice. `kind`/`key` are the member's identity; `manifest`/
+ * `key_path` name the collection address it surfaces at; `fields` are its folded typed
+ * fields — the entry value the write face places under `key`.
+ *
+ * **Seam-inbound with `fields`.** The lock's `registration` declaration family records
+ * only the identity and address: the fields live in the projected manifest artifact, never
+ * a second copy the engine reads back (0018, "the projection is not the database"), so a
+ * row read back off the lock carries an empty `fields`.
+ */
+export type RegistrationRow = {
+    /**
+     * The registration kind's bare name — `hook`, `mcp-server` — joining `declarations.kinds`.
+     */
+    kind: string;
+    /**
+     * The member's key among its collection's entries — a hook's event, a server's name.
+     */
+    key: string;
+    /**
+     * The host manifest the registration surfaces in (`settings.json`, `.mcp.json`).
+     */
+    manifest: string;
+    /**
+     * The manifest key-path label the registration keys at (`hooks.<Event>`, `mcpServers.*`).
+     */
+    key_path: string;
+    /**
+     * The member's folded typed fields — seam-inbound only, dropped from the lock row.
+     */
+    fields: Array<[string, unknown]>;
+};

package/dist/src/generated/RegistrationRow.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

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

@@ -0,0 +1,25 @@
+/**
+ * One harness-level settings-residue key the SDK erased for the manifest write face — an
+ * opaque top-level key of the manifest it names (Claude Code's `settings.json`) with no
+ * typed member kind of its own yet. Carried across the seam so `emit` folds it into that
+ * manifest's opaque residue beside the collection segments its registration members build.
+ *
+ * **Seam-inbound with `value`.** Like a composed-prose include, this row is consumed at
+ * emit and never written into the lock's declaration table: the value lives in the
+ * projected manifest artifact, never a second copy the engine reads back (0018), so a lock
+ * round-trip carries none.
+ */
+export type SettingsRow = {
+    /**
+     * The host manifest the residue key surfaces in (`settings.json`).
+     */
+    manifest: string;
+    /**
+     * The residue key — an opaque top-level manifest key with no member home.
+     */
+    key: string;
+    /**
+     * The key's opaque JSON value, placed verbatim into the manifest's residue.
+     */
+    value: unknown;
+};

package/dist/src/generated/SettingsRow.js

@@ -0,0 +1,2 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+export {};

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

@@ -2,6 +2,7 @@ export type { AssemblyFactRow } from "./AssemblyFactRow.js";
 export type { BoundRow } from "./BoundRow.js";
 export type { CharsetRow } from "./CharsetRow.js";
 export type { ClauseRow } from "./ClauseRow.js";
+export type { CollectionAddressRow } from "./CollectionAddressRow.js";
 export type { CollectionEntryRow } from "./CollectionEntryRow.js";
 export type { CollectionEntryWire } from "./CollectionEntryWire.js";
 export type { CountBoundRow } from "./CountBoundRow.js";
@@ -22,8 +23,10 @@ export type { NestedMemberRow } from "./NestedMemberRow.js";
 export type { Payload } from "./Payload.js";
 export type { PayloadMember } from "./PayloadMember.js";
 export type { RangeBoundRow } from "./RangeBoundRow.js";
+export type { RegistrationRow } from "./RegistrationRow.js";
 export type { RequirementRow } from "./RequirementRow.js";
 export type { SatisfiesRow } from "./SatisfiesRow.js";
 export type { Section } from "./Section.js";
 export type { SectionContainsRow } from "./SectionContainsRow.js";
+export type { SettingsRow } from "./SettingsRow.js";
 export type { ValueType } from "./ValueType.js";

package/dist/src/index.d.ts

@@ -18,11 +18,11 @@ export type { Capability } from "./needs.js";
 export { bash, capability, permissionUnion } from "./needs.js";
 export type { Charset, Clause, Predicate, Requirement, Severity } from "./contract.js";
 export { allowedChars, clause, count, degree, deny, enumOf, forbiddenKeys, maxLen, maxLines, membership, minLen, mustDefine, nameMatchesDir, optional, range, required, requireSections, requirement, sectionContains, type, unique, uniqueName, } from "./contract.js";
-export type { EdgeField, EmbeddedMemberCollectionEntry, EmbeddedMemberValue, Format, KindDefinition, KindFacts, Layout, LayoutRegion, Locus, Member, MemberInit, Registration, UnitShape, } from "./kind.js";
+export type { CollectionAddress, EdgeField, EmbeddedMemberCollectionEntry, EmbeddedMemberValue, Format, KindDefinition, KindFacts, Layout, LayoutRegion, Locus, Member, MemberInit, Registration, Shape, UnitShape, } from "./kind.js";
 export { embeddedMemberValue, kind } from "./kind.js";
 export type { EnforcementMode, ExpectBinding, Harness } from "./assembly.js";
 export { harness } from "./assembly.js";
 export type { AssemblyFactRow, ClauseRow, Declarations, KindFactRow, RequirementRow, SatisfiesRow, } from "./declarations.js";
 export { SEAM_VERSION, compileDeclarations } from "./declarations.js";
-export type { EmitResult, PayloadMember, ResolveOptions } from "./emit.js";
+export type { EmitResult, PayloadMember, RegistrationFact, ResolveOptions } from "./emit.js";
 export { emit } from "./emit.js";

package/dist/src/kind.d.ts

@@ -1,10 +1,12 @@
 /**
  * Kinds — the engine room. A kind is a plain typed surface — an interface
  * `T` and a constructor `kind<T>()` — plus six facts of runtime residue: label,
- * locus, layout, registration, edge fields, and content. `tsc` is the keystroke wall;
- * every type erases at the seam, and what a kind leaves behind is those six facts,
- * riding the lock as rows. Identity travels by import, never by string — a `kind`
- * reference is the imported value.
+ * locus, layout, registration, edge fields, and content. A registration kind (a hook,
+ * an MCP server) extends the content fact with a fields-only `shape` and a
+ * `collectionAddress` naming the host manifest it surfaces in. `tsc` is the keystroke
+ * wall; every type erases at the seam, and what a kind leaves behind rides the lock as
+ * rows. Identity travels by import, never by string — a `kind` reference is the imported
+ * value.
  */
 import type { Prose, Text } from "./prose.js";
 import type { Capability } from "./needs.js";
@@ -86,6 +88,23 @@ export type LayoutRegion = {
 export interface Layout {
     readonly regions: readonly LayoutRegion[];
 }
+/**
+ * A kind's **body shape** marker — `"fields"` for a fields-only kind: no body slot at
+ * all, the member its typed fields and edges and nothing more (a hook, an MCP server).
+ * Absent leaves the kind body-bearing, its body `file` (the default) or a declared
+ * {@link Layout}.
+ */
+export type Shape = "fields";
+/**
+ * A registration member's **collection address** — where inside a host manifest its
+ * registration surfaces: which `manifest` (`settings.json`, `.mcp.json`) and which
+ * `keyPath` (`hooks.<Event>`, `mcpServers.*`) it keys at. Carried by a fields-only
+ * registration kind; absent for a kind that owns its own file locus.
+ */
+export interface CollectionAddress {
+    readonly manifest: string;
+    readonly keyPath: "hooks.<Event>" | "mcpServers.*";
+}
 /** The six facts of a kind's runtime residue. */
 export interface KindFacts {
     /** Fact 1, label — the compiled debug label findings speak; the kind's name. */
@@ -115,6 +134,12 @@ export interface KindFacts {
     /** Fact 6, content — a declared {@link Layout} over the body's heading tree; absent
      * leaves the kind `file`-content (one verbatim prose body, the default). */
     readonly content?: Layout;
+    /** Fact 6b, content — the fields-only body shape (`"fields"`, no body slot); absent
+     * leaves the kind body-bearing (`file` or a {@link Layout}). */
+    readonly shape?: Shape;
+    /** The registration member's {@link CollectionAddress} — which manifest and key path
+     * its registration surfaces at; absent for a kind that owns its own file locus. */
+    readonly collectionAddress?: CollectionAddress;
 }
 /**
  * One authored member — a typed value in the library. Kind identity travels by

package/dist/src/kind.js

@@ -1,21 +1,25 @@
 /**
  * Kinds — the engine room. A kind is a plain typed surface — an interface
  * `T` and a constructor `kind<T>()` — plus six facts of runtime residue: label,
- * locus, layout, registration, edge fields, and content. `tsc` is the keystroke wall;
- * every type erases at the seam, and what a kind leaves behind is those six facts,
- * riding the lock as rows. Identity travels by import, never by string — a `kind`
- * reference is the imported value.
+ * locus, layout, registration, edge fields, and content. A registration kind (a hook,
+ * an MCP server) extends the content fact with a fields-only `shape` and a
+ * `collectionAddress` naming the host manifest it surfaces in. `tsc` is the keystroke
+ * wall; every type erases at the seam, and what a kind leaves behind rides the lock as
+ * rows. Identity travels by import, never by string — a `kind` reference is the imported
+ * value.
  */
 /** The framework keys of a member init — everything else is a typed field (flat). */
 const FRAMEWORK_KEYS = new Set(["name", "prose", "satisfies", "requires", "needs"]);
 /**
- * Build the ordered projected-frontmatter fields for a member: nothing for a
- * frontmatterless kind (memory declares no `format`), else the identity field
- * (when the kind writes its name into frontmatter) followed by the typed fields
- * in the author's declared order.
+ * Build the ordered projected fields for a member: nothing for a frontmatterless
+ * body-bearing kind (memory declares no `format` and is not fields-only), else the
+ * identity field (when the kind writes its name into frontmatter) followed by the
+ * typed fields in the author's declared order. A fields-only registration kind (a
+ * hook, an MCP server) carries its typed fields though it declares no `format` —
+ * the fields are the whole member, folded into a manifest entry, never a header.
  */
 function orderedFields(facts, init) {
-    if (facts.format === undefined)
+    if (facts.format === undefined && facts.shape !== "fields")
         return [];
     const typed = [];
     for (const [key, value] of Object.entries(init)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtmd/temper",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "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": {
@@ -32,6 +32,7 @@
   },
   "files": [
     "dist/src",
+    "bin",
     "README.md"
   ],
   "publishConfig": {
@@ -46,5 +47,12 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typescript": "^5.6.0"
+  },
+  "bin": {
+    "temper": "bin/temper.js"
+  },
+  "optionalDependencies": {
+    "@dtmd/temper-linux-x64": "0.0.7",
+    "@dtmd/temper-win32-x64": "0.0.7"
   }
 }