README.md

@@ -47,7 +47,7 @@ own resolved environment.
 - **A module's API client and its tool implementations** → in the module. (The Plex client, the
   Umami client, `tools/plex.ts` — all module-local. ADR 0039.)
 - **Delivery machinery** — build executor, bundler, dependency resolver, artifact manager, feature
-  handlers → **mesh-control**. It co-evolves with the pipeline.
+  handlers → **mesh-controller**. It co-evolves with the pipeline.
 - **Host synchronisers** — config-sync, ufw config, vhost generation, systemd, health checks →
   **mesh-host**'s apply engine. The host applies these; they are not module code.
 - **Domain logic** — tasks, workflows, agents, provider integrations → **tier-2 contexts**.

module.json

@@ -0,0 +1,11 @@
+{
+  "module": "mesh-sdk",
+  "version": "1",
+  "slug": "sdk",
+  "build": {
+    "artifacts": [
+      { "name": "lib", "kind": "package", "language": "typescript" }
+    ]
+  },
+  "resources": []
+}

src/contracts/index.ts

@@ -1,39 +1,13 @@
 // The runtime shapes a module's own code touches — NOT the manifest schema, which the control
-// plane owns and parses (in Go). These are what a running module receives and returns: a grant
-// and its credentials, the mesh interface a provider and consumer both conform to, and the tool
-// and event types. They change rarely and deliberately (novox/hq ADR 0039).
-
-/** A request for one instance of a provided resource, addressed to a provider. */
-export interface Grant {
-  /** The mesh interface being provisioned, e.g. "analytics", "postgres-database". */
-  readonly resource: string;
-  /** Who asked — the consumer module, on which node. */
-  readonly consumer: string;
-  readonly node: string;
-  /** What the consumer contributed (per the interface's spec keys), e.g. `{ name: "umami" }`. */
-  readonly values: Readonly<Record<string, string>>;
-}
-
-/** What a provider hands back for a grant. Sealed by the harness before it leaves the machine. */
-export interface Credential {
-  /** The fields the interface promises a consumer, e.g. `{ host, port, as, password }`. */
-  readonly fields: Readonly<Record<string, string>>;
-}
-
-/**
- * A mesh interface: the provider-neutral contract for a capability (novox/hq ADR 0040). Both a
- * provider (which adapts its software to it) and a consumer (which depends on it, never on a
- * provider) conform. `spec` names what a consumer may contribute; `credential` names what it
- * receives. The interface is drawn at the consumer's real coupling: neutral where thin
- * (`analytics`), the protocol where the consumer speaks one (`postgres-database`).
- */
-export interface Interface {
-  readonly name: string;
-  /** Keys a consumer may contribute when requesting it. */
-  readonly spec: readonly string[];
-  /** Fields a consumer receives in its credential. */
-  readonly credential: readonly string[];
-}
+// plane owns and parses (in Go). What is here is what actually crosses the wire: the tool
+// definition and the event envelope. They change rarely and deliberately (novox/hq ADR 0039).
+//
+// **The provisioning shapes are NOT here, and used to be — wrongly.** Grant, Credential and an
+// Interface type lived here, exported and imported by nothing, and they described a grant with
+// fields (`resource`, `consumer`) the live wire does not use: the wire is the contributions file,
+// whose shape is in `provisioner/index.ts` and agrees with the Go side. Dead types that
+// contradict the live wire are worse than none — they read as the contract and are not, which is
+// exactly how ADR 0074 came to claim a drift that was not there. Removed.
 
 /** A tool a module exposes through the mesh's command surface. */
 export interface ToolDefinition {

src/messaging/index.ts

@@ -9,7 +9,7 @@ export type { Envelope, EventHeaders };
 
 /** A request/reply call and a publish/subscribe surface over the mesh broker. */
 export interface Broker {
-  /** Ask one question and await one answer — the client side; the shape mesh-control's command
+  /** Ask one question and await one answer — the client side; the shape mesh-controller's command
    *  API is reached by. */
   request<Req, Res>(key: string, body: Req): Promise<Res>;
   /** Answer a question — the server side of request/reply. A tool runtime serves invocations this

test/sdk.test.ts

@@ -106,7 +106,7 @@ test("modules can SERVE: a real async tool, loaded and invoked over the broker",
   const broker = memBroker();
   const stop = await serveTools(broker, {});
 
-  // Invoke it the way a caller (mesh-control's command API) would — over the broker, by module and
+  // Invoke it the way a caller (mesh-controller's command API) would — over the broker, by module and
   // tool, each served on its own key `demo.create_site` (novox/hq ADR 0047).
   const result = (await invokeTool(broker, "demo", "create_site", { domain: "my-app" })) as { snippet: string };
   assert.match(result.snippet, /data-website-id="site-123"/);